marv 0.3.2 → 0.4.0

data/layouts/theme/assets/stylesheets/_header.scss

@@ -0,0 +1,18 @@
+/*!
+ * Theme Name: <%= project_config[:name] %>
+ * Theme URI: <%= project_config[:uri] %>
+ * Author: <%= project_config[:author] %>
+ * Author URI: <%= project_config[:author_uri] %>
+ * Description: <%= project_config[:description] %>
+ * Version: <%= project_config[:version] %>
+ * License: <%= project_config[:license_name] %>
+ * License URI: <%= project_config[:license_uri] %>
+ * Tags: <%= project_config[:tags] %>
+<% if project_config[:template] -%>
+ * Template: <%= project_config[:template] %>
+<% end -%>
+<%- unless project_config[:comments].nil? || project_config[:comments].empty? -%>
+ *
+ * Comments: <%= project_config[:comments] %>
+<%- end -%>
+ */

data/lib/marv.rb

@@ -1,11 +1,11 @@
-require 'marv/error'
+require 'thor'
+require 'marv/cli'
+require 'marv/global'
 
 module Marv
-  ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-  autoload :Guard, 'marv/guard'
-  autoload :CLI, 'marv/cli'
-  autoload :Project, 'marv/project'
-  autoload :Builder, 'marv/builder'
-  autoload :Generator, 'marv/generator'
-  autoload :Server, 'marv/server'
+
+  def self.root
+    ::File.expand_path(::File.join(::File.dirname(__FILE__), '..'))
+  end
+
 end

data/lib/marv/cli.rb

@@ -1,202 +1,25 @@
-require 'thor'
-require 'guard/marv/assets'
-require 'guard/marv/config'
-require 'guard/marv/templates'
-require 'guard/marv/functions'
-require 'guard/marv/folders'
+require 'marv/cli/project'
+require 'marv/cli/server'
 
 module Marv
-  class CLI < Thor
+  module CLI
+    class Commands < Project
 
-    include Thor::Actions
-
-    def self.source_root
-      File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'layouts'))
-    end
-
-    desc "create DIRECTORY", "Creates a Marv project into specified directory"
-    long_desc "Creates a new project. Use the layout option to choose a scaffold"
-    method_option :layout, :type => :string, :default => 'theme', :enum => %w{theme plugin}, :desc => "Scaffold layout for theme or plugin"
-    method_option :local, :type => :boolean, :force => false, :desc => "Use custom layout from ~/.marv/layouts folder"
-    def create(dir)
-      theme = {}
-      theme[:name] = dir
-
-      project = Marv::Project.create(dir, theme, self, options[:layout], options[:local])
-    end
-
-    desc "link SERVER or DIRECTORY", "Create a symbolic link to the compilation directory"
-    long_desc "This command will symlink the compiled version of the project to the specified server or WordPress install path."+
-    "If you don't provide a directory or a server name, the symlink will be created in Marv global themes or plugins folder."
-    method_option :folder, :type => :string, :enum => %w{themes plugins}, :required => true, :desc => "Link Marv project in themes or plugins folfer"
-    def link(dir=nil)
-      project = Marv::Project.new('.', self)
-
-      unless File.directory?(project.build_path)
-        FileUtils.mkdir_p project.build_path
-      end
-
-      if dir.nil?
-        link_project_globaly(options, project)
-      else
-        wp_path = File.join(dir, 'wp-content', options[:folder])
-        server_path = File.join(ENV['HOME'], '.marv', 'servers', dir, 'wp-content', options[:folder])
-        link_project(wp_path, server_path, project)
-      end
-    end
-
-    desc "watch", "Start watch process"
-    long_desc "Watches the source directory in your Marv project for changes, and reflects those changes in a compile folder"
-    method_option :config, :type => :string, :desc => "Name of alternate config file"
-    def watch
-      project = Marv::Project.new('.', self, nil, options[:config])
-
-      # Empty the build directory before starting up to clean out old files
-      FileUtils.rm_rf project.build_path
-      FileUtils.mkdir_p project.build_path
-
-      Marv::Guard.start(project, self)
-    end
-
-    desc "build DIRECTORY", "Build your theme into specified directory"
-    method_option :config, :type => :string, :desc => "Name of alternate config file"
-    def build(dir='build')
-      project = Marv::Project.new('.', self, nil, options[:config])
-
-      builder = Builder.new(project)
-      builder.build
-
-      Dir.glob(File.join(dir, '**', '*')).each do |file|
-        shell.mute { remove_file(file) }
-      end
-
-      directory(project.build_path, dir)
-    end
-
-    desc "package FILENAME", "Compile and zip your Marv project to FILENAME.zip"
-    method_option :config, :type => :string, :desc => "Name of alternate config file"
-    def package(filename=nil)
-      project = Marv::Project.new('.', self, nil, options[:config])
-
-      builder = Builder.new(project)
-      builder.build
-      builder.zip(filename)
-    end
-
-    desc "server SERVER", "Create a Marv server with the specified name"
-    method_option :list, :type => :boolean, :force => false, :desc => "List all available Marv servers"
-    method_option :start, :type => :boolean, :force => false, :desc => "Create a new Marv server"
-    method_option :stop, :type => :boolean, :force => false, :desc => "Stop a running Marv server"
-    method_option :restart, :type => :boolean, :force => false, :desc => "Restart a Marv server"
-    # method_option :backup, :type => :boolean, :force => false, :desc => "Backup a Marv server"
-    # method_option :restore, :type => :boolean, :force => false, :desc => "Restore a Marv server"
-    method_option :remove, :type => :boolean, :force => false, :desc => "Remove a Marv server"
-    def server(name=nil)
-      if options.empty?
-        server = Marv::Server.new(name, self, server_config)
-        server.create_server
+      def self.source_root
+        ::File.expand_path(::File.join(Marv.root, 'layouts'))
       end
 
-      if options[:remove]
-        server = Marv::Server.new(name, self, server_config(true, name))
-        server.remove_server
+      # Configure marv
+      desc "config", "Configure Marv projects and servers"
+      long_desc "Creates a global config.rb file that can be used to auto-configure your projects and servers"
+      def config
+        global = Marv::Global.new(self)
+        global.reconfigure
       end
 
-      if options[:start] or options[:stop] or options[:restart]
-        server = Marv::Server.new(name, self, nil)
-        control_server(options, name, server)
-      end
+      desc "server [SUBCOMMAND]", "Manage marv servers (create, start and more...)"
+      subcommand "server", Server
 
-      if options[:list]
-        list_servers
-      end
     end
-
-    protected
-
-    def link_project_globaly(options, project)
-      project_folder = project.project_id.gsub('_', '-')
-      global_folder = File.join(ENV['HOME'], '.marv', options[:folder])
-
-      unless File.directory?(global_folder)
-        FileUtils.mkdir_p global_folder
-      end
-
-      do_link(project, File.join(global_folder, project_folder))
-
-      servers = Dir.glob(File.join(ENV['HOME'], '.marv', 'servers' , '*'))
-
-      servers.each do |server|
-        shell.mute { do_link(project, File.join(server, 'wp-content', options[:folder], project_folder)) }
-      end
-    end
-
-    def server_config(remove=nil, name=nil)
-      config = {}
-
-      if remove.nil?
-        say "This will create a new Marv server with WordPress installed:", :green
-      else
-        say "This will remove #{name} server:", :yellow
-      end
-
-      config[:user] = ask("Mysql username:", nil, {:default => "root"})
-      config[:password] = ask("Mysql user password:", nil, {:default => "required"})
-      config[:host] = ask("Mysql host:", nil, {:default => "localhost"})
-      config[:port] = ask("Mysql port:", nil, {:default => "3306"})
-
-      if remove.nil?
-        config[:version] = ask("WordPress version:", nil, {:default => "latest"})
-      end
-
-      config
-    end
-
-    def control_server(options, name, server)
-      if options[:start]
-        server.start_server
-      end
-
-      if options[:stop]
-        server.stop_server
-      end
-
-      if options[:restart]
-        server.restart_server
-      end
-    end
-
-    def list_servers
-      servers_root = File.join(ENV['HOME'], '.marv', 'servers')
-      servers = Dir.glob(File.join(servers_root, '*'))
-
-      say "Available marv servers:"
-      servers.each do |server|
-        say '- ' + File.basename(server), :cyan
-      end
-    end
-
-    def link_project( wp_path, server_path, project)
-      project_folder = project.project_id.gsub('_', '-')
-
-      if File.directory?(wp_path)
-        do_link(project, File.join(wp_path, project_folder))
-      else
-        do_link(project, File.join(server_path, project_folder))
-      end
-    end
-
-    def do_link(project, path)
-      begin
-        project.link(path)
-      rescue LinkSourceDirNotFound
-        say_status :error, "The path #{File.dirname(path)} does not exist", :red
-        exit 2
-      rescue Errno::EEXIST
-        say_status :error, "The path #{path} already exists", :red
-        exit 2
-      end
-    end
-
   end
-end
+end

data/lib/marv/cli/project.rb

@@ -0,0 +1,57 @@
+require 'marv/project/project'
+
+module Marv
+  module CLI
+    class Project < Thor
+
+      include Thor::Actions
+
+      # Create a new Marv project
+      desc "create DIRECTORY", "Creates a Marv project into specified directory"
+      long_desc "Creates a new project. Use the layout option to choose a scaffold"
+      def create(dir)
+        Marv::Project::Create.new(self, dir)
+      end
+
+      # Link an existing project to a Marv server or an existing WordPress installation
+      desc "link SERVER or DIRECTORY", "Create a symbolic link to the compilation directory"
+      long_desc "This command will symlink the compiled version of the project to the specified server or WordPress install path."+
+      "If you don't provide a directory or a server name, the symlink will be created in Marv global themes or plugins folder."
+      def link(dir=nil)
+        project = Marv::Project::Project.new(self, '.', nil)
+        actions = Marv::Project::Actions.new(project, nil)
+        actions.link(dir)
+      end
+
+      # Watch a Marv project for changes
+      desc "watch", "Start watch process"
+      long_desc "Watches the source directory in your Marv project for changes, and reflects those changes in a compile folder"
+      method_option :config, :type => :string, :desc => "Name of alternate config file"
+      def watch
+        project = Marv::Project::Project.new(self, '.', options[:config])
+        builder = Marv::Project::Builder.new(project)
+        Marv::Project::Guard.start(project, builder)
+      end
+
+      # Build a Marv project to a directory
+      desc "build DIRECTORY", "Build your theme into specified directory"
+      method_option :config, :type => :string, :desc => "Name of alternate config file"
+      def build(dir='build')
+        project = Marv::Project::Project.new(self, '.', options[:config])
+        builder = Marv::Project::Builder.new(project)
+        builder.build_to(dir)
+      end
+
+      # Package a Marv project in a .zip file
+      desc "package FILENAME", "Compile and zip your Marv project to FILENAME.zip"
+      method_option :config, :type => :string, :desc => "Name of alternate config file"
+      def package(filename=nil)
+        project = Marv::Project::Project.new(self, '.', options[:config])
+        builder = Marv::Project::Builder.new(project)
+        actions = Marv::Project::Actions.new(project, builder)
+        actions.package(filename)
+      end
+
+    end
+  end
+end

data/lib/marv/cli/server.rb

@@ -0,0 +1,65 @@
+require 'marv/server/server'
+
+module Marv
+  module CLI
+    class Server < Thor
+
+      def self.source_root
+        ::File.expand_path(::File.join(Marv.root, 'layouts'))
+      end
+
+      include Thor::Actions
+
+      # List all Marv servers
+      desc "list", "List all Marv servers"
+      def list
+        servers = Marv::Global.new(self).servers
+
+        say "Available marv servers:"
+        servers.each do |server|
+          say '- ' + server, :cyan
+        end
+      end
+
+      # Create a new Marv server
+      desc "create SERVER", "Create a Marv server with the specified name"
+      def create(dir)
+        server = Marv::Server::Server.new(self, dir)
+        Marv::Server::Create.new(server)
+      end
+
+      # Start a Marv server
+      desc "start SERVER", "Start the specified Marv server"
+      def start(dir)
+        server = Marv::Server::Server.new(self, dir)
+        action = Marv::Server::Actions.new(server)
+        action.start
+      end
+
+      # Start a Marv server
+      desc "stop SERVER", "Stop the specified Marv server"
+      def stop(dir)
+        server = Marv::Server::Server.new(self, dir)
+        action = Marv::Server::Actions.new(server)
+        action.stop
+      end
+
+      # Start a Marv server
+      desc "restart SERVER", "Restart the specified Marv server"
+      def restart(dir)
+        server = Marv::Server::Server.new(self, dir)
+        action = Marv::Server::Actions.new(server)
+        action.restart
+      end
+
+      # Create a new Marv server
+      desc "remove SERVER", "Remove the specified Marv server"
+      def remove(dir)
+        server = Marv::Server::Server.new(self, dir)
+        action = Marv::Server::Actions.new(server)
+        action.remove
+      end
+
+    end
+  end
+end

data/lib/marv/global.rb

@@ -0,0 +1,285 @@
+module Marv
+  class Global
+
+    attr_accessor :config, :path, :servers, :plugins, :themes, :layouts
+
+    def initialize(task)
+      @task = task
+
+      create_global_folders
+      create_global_config
+
+      @path = global_path
+      @config = global_config
+      @servers = local_servers
+      @plugins = global_plugins
+      @themes = global_themes
+      @layouts = global_layouts
+
+      @task.shell.mute do
+        clean_broken_links(global_projects_paths)
+        link_global_projects
+      end
+    end
+
+    # Global Marv folder path
+    def global_path
+      ::File.join(ENV['HOME'], '.marv')
+    end
+
+    # Global config file
+    def config_file
+      ::File.join(::File.join(global_path, 'config.rb'))
+    end
+
+    # Load global config file
+    def global_config
+      load_ruby_config(config_file)
+    end
+
+    # Servers folder path
+    def servers_path
+      ::File.join(global_path, 'servers')
+    end
+
+    # Local servers array
+    def local_servers
+      @servers = subfolders_basenames(servers_path)
+    end
+
+    # Plugins path
+    def plugins_path
+      ::File.join(global_path, 'plugins')
+    end
+
+    # Themes path
+    def themes_path
+      ::File.join(global_path, 'themes')
+    end
+
+    # Layouts path
+    def layouts_path
+      ::File.join(global_path, 'layouts')
+    end
+
+     # Global themes array
+    def global_themes
+      @themes = subfolders_basenames(themes_path)
+    end
+
+    # Global plugins array
+    def global_plugins
+      @plugins = subfolders_basenames(plugins_path)
+    end
+
+    # Global layouts array
+    def global_layouts
+      @layouts = subfolders_basenames(layouts_path)
+    end
+
+    # Create global folders
+    def create_global_folders
+      @task.shell.mute do
+        create_global_path
+        create_servers_path
+        create_themes_path
+        create_plugins_path
+        create_layouts_path
+      end
+    end
+
+    # Create global path
+    def create_global_path
+      unless ::File.directory?(global_path)
+        @task.empty_directory global_path
+      end
+    end
+
+    # Create servers path
+    def create_servers_path
+      unless ::File.directory?(servers_path)
+        @task.empty_directory servers_path
+      end
+    end
+
+    # Create themes path
+    def create_themes_path
+      unless ::File.directory?(themes_path)
+        @task.empty_directory themes_path
+      end
+    end
+
+    # Create plugins path
+    def create_plugins_path
+      unless ::File.directory?(plugins_path)
+        @task.empty_directory plugins_path
+      end
+    end
+
+    # Create layouts path
+    def create_layouts_path
+      unless ::File.directory?(layouts_path)
+        @task.empty_directory layouts_path
+      end
+    end
+
+    # Server details
+    def ask_server_details
+      options = {}
+
+      if @task.yes?("Do you want to set default server settings?")
+        options[:server_host] = @task.ask "Default host for servers?", :default => "localhost"
+        options[:server_port] = @task.ask "Default port for servers?", :default => "3000"
+      end
+
+      return options
+    end
+
+    # Database details
+    def ask_database_details
+      options = {}
+
+      if @task.yes?("Do you want to set default database settings?")
+        options[:db_user] = @task.ask "Default database username?", :default => "root"
+        options[:db_password] = @task.ask "Default database password?", :default => "root"
+        options[:db_host] = @task.ask "Default database host?", :default => "localhost"
+        options[:db_port] = @task.ask "Default database port?", :default => "3306"
+      end
+
+      return options
+    end
+
+    # Wordpress details
+    def ask_wordpress_details
+      options = {}
+
+      if @task.yes?("Do you want to set default WordPress version?")
+        options[:wp_version] = @task.ask "Default WordPress version?", :default => "latest"
+      end
+
+      return options
+    end
+
+    # Get global options
+    def global_options
+      @options
+    end
+
+    # Ask global options
+    def ask_global_options
+      options = {}
+
+      @task.say "This will create a new global configuration file.", :cyan
+
+      if @task.yes?("Do you want to set default project details?")
+        options[:uri] = @task.ask "Default project URI"
+        options[:author] = @task.ask "Default project author"
+        options[:author_uri] = @task.ask "Default project author URI"
+        options[:license_name] = @task.ask "Default project license name"
+        options[:license_uri] = @task.ask "Default project license URI"
+      end
+
+      options.merge!(ask_server_details)
+      options.merge!(ask_database_details)
+      options.merge!(ask_wordpress_details)
+
+      @options = options
+    end
+
+    # Create global config
+    def create_global_config
+      unless ::File.exists?(config_file)
+        ask_global_options
+        template ::File.join(Marv.root, 'layouts', 'config', 'global.rb'), ::File.join(global_path, 'config.rb'), instance_eval('binding')
+      end
+    end
+
+    # Reconfig Marv global options
+    def reconfigure
+      @task.say "This will overwrite your global configuration file.", :cyan
+
+      if @task.yes?("Do you want to continue?")
+        @task.shell.mute do
+          @task.remove_file config_file
+        end
+
+        create_global_folders
+        create_global_config
+      end
+    end
+
+    # Global projects paths
+    def global_projects_paths
+      paths = ::Dir.glob(::File.join(plugins_path, '*'))
+      paths = paths + ::Dir.glob(::File.join(themes_path, '*'))
+
+      return paths
+    end
+
+    # Global servers paths
+    def global_servers_paths
+      ::Dir.glob(::File.join(servers_path, '*'))
+    end
+
+    # Clean broken global links
+    def clean_broken_links(paths)
+      paths.each do |path|
+        unless ::File.exists?(path)
+          ::FileUtils.rm_r path
+        end
+      end
+    end
+
+    # Link global projects
+    def link_global_projects
+      global_projects_paths.each do |project|
+        global_servers_paths.each do |server|
+          target = project.gsub(global_path, ::File.join(server, 'wp-content'))
+          @task.create_link target, project unless ::File.exists?(target)
+        end
+      end
+    end
+
+    # Load ruby config file
+    def load_ruby_config(file)
+      config = {}
+
+      begin
+        # Config file is just executed as straight ruby
+        eval(::File.read(file))
+      rescue Exception => e
+        @task.say "Error while evaluating config file:"
+        @task.say e.message, :red
+      end
+
+      return config
+    end
+
+    # Parse template from source to destination
+    def template(source, *args, &block)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      destination = args.first || source.sub(/\.tt$/, '')
+      context = args.last || instance_eval('binding')
+
+      source  = ::File.expand_path(@task.find_in_source_paths(source.to_s))
+
+      @task.create_file destination, nil, config do
+        content = ERB.new(::File.binread(source), nil, '-', '@output_buffer').result(context)
+        content = block.call(content) if block
+        content
+      end
+    end
+
+    # Get subfolder basenames
+    def subfolders_basenames(folder)
+      subfolders = []
+
+      ::Dir.glob(::File.join(folder, '*')).each do |subfolder|
+        subfolders << ::File.basename(subfolder)
+      end
+
+      return subfolders
+    end
+
+  end
+end