marv 0.3.2 → 0.4.0

data/lib/marv/error.rb

@@ -1,8 +0,0 @@
-module Marv
-  class Error < StandardError
-  end
-
-  # Raised when the link source could not be found
-  class LinkSourceDirNotFound < Error
-  end
-end

data/lib/marv/generator.rb

@@ -1,140 +0,0 @@
-module Marv
-  class Generator
-
-    class << self
-      def run(project, layout, local_layout)
-        generator = self.new(project, layout, local_layout)
-        generator.run
-      end
-    end
-
-    def initialize(project, layout, local_layout)
-      @project = project
-      @task    = project.task
-      @layout  = layout
-      @local   = local_layout
-    end
-
-    def create_structure
-      # Create the build directory for Marv output
-      @task.empty_directory @project.build_path
-
-      source_paths = [
-        ['assets', 'images'],
-        ['assets', 'javascripts'],
-        ['assets', 'stylesheets'],
-
-        ['functions'],
-        ['includes'],
-
-        ['templates', 'pages'],
-        ['templates', 'partials'],
-      ]
-
-      # Build out Marv structure in the source directory
-      source_paths.each do |path|
-        @task.empty_directory File.join(@project.source_path, path)
-      end
-
-      self
-    end
-
-    def copy_assets
-      ['stylesheets', 'javascripts', 'images'].each do |folder|
-        source = File.expand_path(File.join(self.layout_path, folder))
-        target = File.expand_path(File.join(@project.assets_path, folder))
-
-        render_directory(source, target)
-      end
-
-      self
-    end
-
-    def copy_folders
-      ['templates', 'includes'].each do |folder|
-        source = File.expand_path(File.join(self.layout_path, folder))
-        target = File.expand_path(File.join(@project.source_path, folder))
-
-        render_directory(source, target)
-      end
-
-      self
-    end
-
-    def copy_functions
-      ['functions.php', @project.project_php_file].each do |file|
-        source = File.expand_path(File.join(self.layout_path, 'functions', "#{file}.erb"))
-        if File.exist?(source)
-          target = File.expand_path(File.join(@project.source_path, 'functions', file))
-          write_template(source, target)
-        end
-      end
-    end
-
-    def layout_path
-      if @local
-        @layout_path ||= File.join(ENV['HOME'], '.marv', 'layouts', @layout)
-      else
-        @layout_path ||= File.join(Marv::ROOT, 'layouts', @layout)
-      end
-    end
-
-    def run
-      write_config
-      create_structure
-      copy_assets
-      copy_folders
-      copy_functions
-
-      return self
-    end
-
-    def write_config
-      unless File.exists?(@project.global_config_file)
-        @task.shell.mute do
-          @task.create_file(@project.global_config_file) do
-            "# Place your global configuration values here\n# config[:livereload] = true"
-          end
-        end
-      end
-
-      write_template(['config', 'project-config.rb'], @project.config_file)
-
-      self
-    end
-
-    def write_template(source, target)
-      source   = File.join(source)
-      template = File.expand_path(@task.find_in_source_paths((source)))
-      target   = File.expand_path(File.join(target))
-
-      @task.create_file target do
-        @project.parse_erb(template)
-      end
-    end
-
-    protected
-
-    def render_directory(source, target)
-      Dir.glob("#{source}/**/*") do |file|
-        unless File.directory?(file)
-          source_file = file.gsub(source, '')
-          target_file = File.join(target, source_file)
-
-          if source_file.end_with? ".erb"
-            target_file = target_file.slice(0..-5)
-
-            content = @project.parse_erb(file)
-          else
-            content = File.open(file).read
-          end
-
-          @task.create_file target_file do
-            content
-          end
-        end
-      end
-    end
-
-  end
-end

data/lib/marv/guard.rb

@@ -1,68 +0,0 @@
-require 'guard'
-require 'guard/guard'
-
-module Marv
-  module Guard
-
-    class << self
-      attr_accessor :project, :task, :builder
-    end
-
-    def self.add_guard(&block)
-      @additional_guards ||= []
-      @additional_guards << block
-    end
-
-    def self.start(project, task, options={}, livereload={})
-      @project = project
-      @task = task
-      @builder = Builder.new(project)
-
-      options_hash = ""
-      options.each do |k,v|
-        options_hash << ", :#{k} => '#{v}'"
-      end
-
-      assets_path = @project.assets_path.gsub(/#{@project.root}\//, '')
-      source_path = @project.source_path.gsub(/#{@project.root}\//, '')
-      config_file = @project.config_file.gsub(/#{@project.root}\//, '')
-
-      guardfile_contents = %Q{
-        guard 'marvconfig'#{options_hash} do
-          watch("#{config_file}")
-        end
-        guard 'marvassets' do
-          watch(%r{#{assets_path}/javascripts/*})
-          watch(%r{#{assets_path}/stylesheets/*})
-          watch(%r{#{assets_path}/images/*})
-        end
-        guard 'marvtemplates' do
-          watch(%r{#{source_path}/templates/*})
-          watch(%r{#{source_path}/partials/*})
-        end
-        guard 'marvfunctions' do
-          watch(%r{#{source_path}/functions/*})
-          watch(%r{#{source_path}/includes/*})
-        end
-        guard 'marvfolders' do
-          watch(%r{#{source_path}/*})
-        end
-      }
-
-      if @project.config[:livereload]
-        guardfile_contents << %Q{
-          guard 'livereload' do
-            watch(%r{#{source_path}/*})
-          end
-        }
-      end
-
-      (@additional_guards || []).each do |block|
-        result = block.call(options, livereload)
-        guardfile_contents << result unless result.nil?
-      end
-      ::Guard.start({ :guardfile_contents => guardfile_contents }).join
-    end
-
-  end
-end

data/lib/marv/project.rb

@@ -1,134 +0,0 @@
-require 'pathname'
-
-module Marv
-  class Project
-
-    class << self
-      def create(root, config, task, layout, local_layout)
-        root = File.expand_path(root)
-
-        project = self.new(root, task, config)
-        Generator.run(project, layout, local_layout)
-
-        project
-      end
-    end
-
-    attr_accessor :root, :config, :task
-
-    def initialize(root, task, config={}, config_file=nil)
-      @root        = File.expand_path(root)
-      @config      = config || {}
-      @task        = task
-      @config_file = config_file
-
-      self.load_config if @config.empty?
-    end
-
-    def assets_path
-      @assets_path ||= File.join(self.source_path, 'assets')
-    end
-
-    def build_path
-      File.join(self.root, '.watch', 'build')
-    end
-
-    def source_path
-      File.join(self.root, 'source')
-    end
-
-    def package_path
-      File.join(self.root, 'package')
-    end
-
-    def templates_path
-      File.join(self.source_path, 'templates')
-    end
-
-    def functions_path
-      File.join(self.source_path, 'functions')
-    end
-
-    def includes_path
-      File.join(self.source_path, 'includes')
-    end
-
-    def config_file
-      @config_file ||= File.join(self.root, 'config.rb')
-    end
-
-    def global_config_file
-      @global_config_file ||= File.join(ENV['HOME'], '.marv', 'config.rb')
-    end
-
-    # Create a symlink from source to the project build dir
-    def link(source)
-      source = File.expand_path(source)
-
-      unless File.writable?(File.dirname(source))
-        @task.say "Permission Denied!", :red
-        @task.say "You do not have write permissions for the destination folder"
-        abort
-      end
-
-      unless File.directory?(File.dirname(source))
-        raise Marv::LinkSourceDirNotFound
-      end
-
-      @task.link_file build_path, source
-    end
-
-    def project_id
-      File.basename(self.root).gsub(/\W/, '_')
-    end
-
-    def project_php_file
-      "#{File.basename(self.root).gsub(/\W/, '-').downcase}.php"
-    end
-
-    def load_config
-      config = {}
-
-      # Check for global (user) config.rb
-      if File.exists?(self.global_config_file)
-        config.merge!(load_ruby_config(self.global_config_file))
-      end
-
-      # Check for config.rb
-      if File.exists?(self.config_file)
-        config.merge!(load_ruby_config(self.config_file))
-      else
-        @task.say "Could not find the config file!", :red
-        @task.say "Are you sure you're in a marv project directory?"
-        abort
-      end
-
-      @config = config
-    end
-
-    def get_binding
-      binding
-    end
-
-    def parse_erb(file)
-      ERB.new(::File.binread(file), nil, '-', '@output_buffer').result(binding)
-    end
-
-    private
-
-    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
-
-  end
-end

data/lib/marv/server.rb

@@ -1,284 +0,0 @@
-require 'net/http'
-require 'mysql2'
-require 'childprocess'
-
-module Marv
-  class Server
-
-    def initialize(name, config, options)
-      @task = config
-
-      # Deploy variables
-      @server_name = name
-      @server_path = server_path
-      @db_name = 'marv_'+name.gsub(/\W/, '_').downcase
-
-      # CLI Options
-      unless options.nil?
-        if options[:password] == "required"
-          @task.say "Mysql password is required. Aborting...", :red
-          abort
-        end
-
-        @wp_version = options[:version]
-        @db_user = options[:user]
-        @db_password = options[:password]
-        @db_host = options[:host]
-        @db_port = options[:port]
-      end
-    end
-
-    def servers_root
-      File.join(ENV['HOME'], '.marv', 'servers')
-    end
-
-    def server_path
-      File.join(ENV['HOME'], '.marv', 'servers', @server_name)
-    end
-
-    def db_name
-      @db_name
-    end
-
-    def db_password
-      @db_password
-    end
-
-    def db_host
-      @db_host
-    end
-
-    def run_php_server
-      # Setup server
-      server = TCPServer.new('127.0.0.1', 0)
-      port = server.addr[1]
-      server.close()
-
-      # Run PHP server
-      ::Dir.chdir @server_path
-      @php = ChildProcess.build 'php', '-S', "localhost:#{port}", 'router.php'
-      @php.start
-
-      # Write PHP proccess id to file
-      File.open(File.join(@server_path, 'php.pid'), 'w') do |file|
-        file.write(@php.pid)
-      end
-
-      @task.say "Visit http://localhost:#{port}"
-    end
-
-    def create_server
-      create_server_directory
-
-      copy_wordpress_files
-      add_config_file('router.php.erb', 'router.php')
-
-      create_server_database
-      add_config_file('wp-config.php.erb', 'wp-config.php')
-
-      add_global_content
-
-      @task.say "Server #{@server_name} created successfuly!", :green
-      @task.say "Start server using marv server #{@server_name} --start"
-      exit
-    end
-
-    def start_server
-      begin
-        update_global_projects
-        run_php_server
-      rescue Exception => e
-        @task.say "Error while starting server:"
-        @task.say e.message + "\n", :red
-      end
-      @task.say "Server #{@server_name} running", :green
-    end
-
-    def stop_server
-      begin
-        @task.shell.mute do
-          php_pid_file = File.join(@server_path, 'php.pid')
-
-          if File.exists?(php_pid_file)
-            php_pid = File.read(php_pid_file).to_i
-
-            Process.kill('KILL', php_pid)
-            @task.say "Server #{@server_name} stopped", :yellow
-          else
-            @task.say "Server #{@server_name} is not running", :red
-          end
-        end
-      rescue Exception => e
-        @task.say "Error while stoping server:"
-        @task.say e.message + "\n", :red
-      end
-    end
-
-    def restart_server
-      stop_server
-      start_server
-    end
-
-    def remove_server
-      @task.say "Removing server..."
-      @task.shell.mute do
-        stop_server
-      end
-      @task.say "Removing server files..."
-
-      begin
-        @task.shell.mute do
-          FileUtils.rm_r(@server_path)
-        end
-        @task.say "Server files removed", :green
-      rescue Exception => e
-        @task.say "Error while removing server files:"
-        @task.say e.message + "\n", :red
-      end
-
-      remove_server_database
-
-      @task.say "Server successfuly removed!", :green
-      exit
-    end
-
-    private
-
-    # Creates a directory for a new server
-    def create_server_directory
-      # Create dir
-      unless ::File.exist?(self.servers_root)
-        ::Dir.mkdir(servers_root)
-      end
-      # Exit if dir exists
-      if ::File.exist?(@server_path)
-        @task.say "A server with name #{@server_name} already exists", :red
-        exit
-      end
-    end
-
-    # Downloads WordPress from wordpress.org
-    def download_wordpress
-      package = "/tmp/wordpress-#{@wp_version}.tar.gz"
-
-      # Download package file
-      @task.shell.mute do
-        unless ::File.exists?(package)
-          @task.get "https://wordpress.org/wordpress-#{@wp_version}.tar.gz" do |content|
-            @task.create_file package, content
-          end
-        end
-      end
-
-      # Return package file
-      package
-    end
-
-    # Copy WordPress files
-    def copy_wordpress_files
-      package = download_wordpress
-
-      # Get package content and extract to dir
-      tmp_dir = "/tmp/wordpress-latest-#{Time.now.to_i}"
-      # Create temporary dir
-      unless ::File.exists?(tmp_dir)
-        Dir.mkdir(tmp_dir)
-      end
-
-      # Extract package to temporary dir
-      @task.shell.mute do
-        @task.run "cd #{tmp_dir};tar -xzf #{package}"
-        @task.directory "#{tmp_dir}/wordpress", @server_path
-      end
-
-      # Remove temporary dir
-      if ::File.exists?(tmp_dir)
-        FileUtils.rm_r(tmp_dir)
-      end
-    end
-
-    def add_config_file(source, target)
-      unless File.exists?(target)
-        config = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'layouts', 'config', source))
-        config_template = ERB.new(::File.binread(config), nil, '-', '@output_buffer')
-
-        File.open(File.join(@server_path, target), 'w') do |file|
-          file.write(config_template.result(binding))
-        end
-      end
-    end
-
-    def create_server_database
-      begin
-        @task.shell.mute do
-          client = Mysql2::Client.new(:host => @db_host, :port => @db_port, :username => @db_user, :password => @db_password)
-          client.query("CREATE DATABASE IF NOT EXISTS #{@db_name}")
-          client.query("GRANT ALL PRIVILEGES ON #{@db_name}.* TO '#{@db_user}'@'#{@db_host}'")
-          client.query("FLUSH PRIVILEGES")
-          client.close
-        end
-      rescue Exception => e
-        @task.say "Error while creating Mysql database:"
-        @task.say e.message + "\n", :red
-        exit
-      end
-    end
-
-    def remove_server_database
-      begin
-        @task.shell.mute do
-          client = Mysql2::Client.new(:host => @db_host, :port => @db_port, :username => @db_user, :password => @db_password)
-          client.query("DROP DATABASE IF EXISTS #{@db_name}")
-          client.query("REVOKE ALL PRIVILEGES ON #{@db_name}.* FROM '#{@db_user}'@'#{@db_host}'")
-          client.query("FLUSH PRIVILEGES")
-          client.close
-        end
-      rescue Exception => e
-        @task.say "Error while removing Mysql database:"
-        @task.say e.message + "\n", :red
-      end
-    end
-
-    def add_global_content
-      @task.shell.mute do
-        global = File.join(ENV['HOME'], '.marv')
-        themes = Dir.glob(File.join(global, 'themes', '*'))
-
-        themes.each do |theme|
-          @task.create_link File.join(@server_path, 'wp-content', 'themes', File.basename(theme)), theme
-        end
-
-        plugins = Dir.glob(File.join(global, 'plugins', '*'))
-
-        plugins.each do |plugin|
-          @task.create_link File.join(@server_path, 'wp-content', 'plugins', File.basename(plugin)), plugin
-        end
-      end
-    end
-
-    def update_global_folders(dir, folders)
-      begin
-        folders.each do |folder|
-          if File.symlink?(folder)
-            unless File.exists?(folder)
-              File.delete(folder)
-              File.delete(File.join(ENV['HOME'], '.marv', dir, File.basename(folder)))
-            end
-          end
-        end
-      rescue Exception => e
-        @task.say "Error while updating global projects:"
-        @task.say e.message + "\n", :red
-      end
-    end
-
-    def update_global_projects
-      themes = Dir.glob(File.join(@server_path, 'wp-content', 'themes', '*'))
-      update_global_folders('themes', themes)
-
-      plugins = Dir.glob(File.join(@server_path, 'wp-content', 'plugins', '*'))
-      update_global_folders('plugins', plugins)
-    end
-
-  end
-end