hem 1.0.1.beta6 → 1.1.0

data/lib/hem/patches/rake.rb

@@ -13,11 +13,8 @@ module Rake
       old_task = Rake.application.instance_variable_get('@tasks').delete(task_name)
 
       Hem::Metadata.to_store task_name
-      task task_name => old_task.prerequisites do
+      task task_name => old_task.prerequisites | new_tasks do
         new_task.call unless new_task.nil?
-        new_tasks.each do |t|
-          Rake::Task[t].invoke
-        end
         old_task.invoke
       end
     end
@@ -25,13 +22,13 @@ module Rake
     def after(task_name, new_tasks = nil, &new_task)
       task_name = task_name.to_s
       new_tasks = [new_tasks].flatten.compact
-      old_task = Rake.application.instance_variable_get('@tasks').delete(task_name)
 
-      Hem::Metadata.to_store task_name
-      task task_name => old_task.prerequisites do
-        old_task.invoke
-        new_tasks.each do |t|
-          Rake::Task[t].invoke
+      task = Rake::Task[task_name]
+      task.enhance do
+        new_tasks.each do |post_task|
+          post = Rake.application.lookup(post_task, task.scope)
+          raise ArgumentError, "Task #{post_task.inspect} not found" unless post
+          post.invoke
         end
         new_task.call unless new_task.nil?
       end
@@ -48,6 +45,25 @@ module Rake
       Rake::Task[task].invoke(*args, &block)
     end
 
+    def argument name, options = {}
+      opts = {
+        optional: false,
+        as: String,
+      }.merge(options)
+      Hem::Metadata.store[:arg_list] ||= {}
+
+      if Hem::Metadata.store[:arg_list].length > 0
+        last_arg = Hem::Metadata.store[:arg_list].values.last
+        if last_arg[:optional] && !opts[:optional]
+          raise 'Cannot have mandatory arguments after optional arguments'
+        elsif last_arg[:as] == Array
+          raise 'Cannot add any arguments after an array argument'
+        end
+      end
+
+      Hem::Metadata.store[:arg_list][name] = opts
+    end
+
     def hidden value = true
       Hem::Metadata.store[:hidden] = value
     end
@@ -59,11 +75,20 @@ module Rake
     def task *args, &block
       name = args[0].is_a?(Hash) ? args[0].keys.first.to_s : args[0]
       scoped_name = Rake.application.current_scope.path_with_task_name(name).to_s
+      Hem::Metadata.store[:arg_list] ||= {}
 
-      [:opts, :desc, :long_desc, :hidden, :project_only].each do |meta|
+      args[1..-1].each do |name|
+        argument name, optional: true
+      end if args.length > 1
+
+      [:opts, :desc, :long_desc, :hidden, :project_only, :arg_list].each do |meta|
         Hem::Metadata.add scoped_name, meta
       end
 
+      if Hem::Metadata.store[:arg_list]
+        args = [args[0], *Hem::Metadata.store[:arg_list].keys]
+      end
+
       Hem::Metadata.reset_store
 
       Hem::Logging.logger.debug("Added metadata to #{scoped_name} -- #{Hem::Metadata.metadata[scoped_name]}")
@@ -94,6 +119,12 @@ module Rake
 
       _old_namespace(name, &block)
     end
+
+    def plugins setup = true, &block
+      Hem.plugins.define &block if block_given?
+      Hem.plugins.setup if setup
+      Hem.plugins
+    end
   end
 end
 

data/lib/hem/plugins.rb

@@ -0,0 +1,129 @@
+module Hem
+  class << self
+    attr_accessor :plugins
+  end
+
+  class Plugins
+
+    def initialize(path, gemfile, lockfile = nil)
+      @is_setup = false
+      @gemfile = gemfile
+      if lockfile.nil?
+        @lockfile = "#{gemfile}.lock"
+      else
+        @lockfile = lockfile
+      end
+
+      @old_root = Bundler.method(:root)
+      def Bundler.root(path = nil)
+        @root = Pathname.new(path) if path
+        @root
+      end
+
+      # ensure Bundler doesn't get it's settings from the project
+      def Bundler.settings
+        return @settings if defined?(@settings)
+        @settings = Bundler::Settings.new
+      end
+
+      # ensure Bundler doesn't use a project's cache
+      def Bundler.app_cache
+        Bundler.rubygems.gem_cache.first
+      end
+
+      Bundler.root path
+      @builder = Class.new(Bundler::Dsl) do
+        define_method(:gemfile_root) do
+          Bundler.root
+        end
+      end.new
+      @definition = nil
+    end
+
+    def setup
+      raise Hem::PluginsAlreadySetupError if @is_setup
+      @is_setup = true
+      install unless check
+      require
+    end
+
+    def setup?
+      @is_setup
+    end
+
+    def define(&block)
+      raise Hem::PluginsAlreadySetupError if @is_setup
+      @builder.instance_eval &block
+
+      self
+    end
+
+    def check
+      return false unless File.exist?(File.join(Bundler.root, @lockfile))
+      begin
+        missing_specs = definition.missing_specs.any?
+      rescue Bundler::GemNotFound, Bundler::VersionConflict, Bundler::GitError
+        missing_specs = true
+      end
+      return !missing_specs
+    end
+
+    def install(options = {})
+      return self if definition.dependencies.empty?
+
+      opts = options.dup
+      opts[:system] = true
+      ui = opts.delete(:ui) { Bundler::UI::Shell.new }
+
+      Bundler.ui = ui
+      begin
+        ENV["BUNDLE_GEMFILE"] = File.join(Bundler.root, @gemfile)
+        Bundler::Installer.install(Bundler.root, definition, opts)
+        ENV.delete("BUNDLE_GEMFILE")
+        Bundler::Installer.post_install_messages.each do |name, message|
+          Hem.ui.info "Post-install message from #{name}:\n#{message}"
+        end
+      rescue Bundler::GemNotFound => e
+        raise e, e.message.sub('Gemfile', 'Hemfile'), e.backtrace
+      rescue Bundler::GitError => e
+        raise e, e.message.sub('bundle install', 'hem plugin install'), e.backtrace
+      end
+
+      self
+    end
+
+    def update(unlock = true, options = {})
+      opts = options.dup
+      opts['update'] = true
+      definition(unlock)
+      install(opts)
+    end
+
+    def require
+      runtime = Bundler::Runtime.new(nil, definition)
+      def runtime.clean_load_path(*); end
+      def runtime.setup_environment(*); end;
+      def runtime.lock(*); end;
+
+      runtime.setup
+      definition.lock(File.join(Bundler.root, @lockfile), :preserve_bundled_with => true) unless @lockfile === false
+
+      runtime.require
+
+      self
+    end
+
+    private
+
+    def definition(unlock = nil)
+      @definition = nil if unlock
+      return @definition unless @definition.nil?
+
+      unlock = {} if unlock.nil?
+      @definition = @builder.to_definition(@lockfile, unlock)
+      @definition.validate_ruby!
+
+      @definition
+    end
+  end
+end

data/lib/hem/setup.rb

@@ -0,0 +1,6 @@
+require 'bundler'
+require_relative 'version'
+require_relative 'plugins'
+
+$:.push File.expand_path(File.join("..", ".."), __FILE__)
+require 'hem'

data/lib/hem/tasks.rb

@@ -0,0 +1,15 @@
+require_relative 'tasks/assets'
+require_relative 'tasks/config'
+require_relative 'tasks/deps'
+require_relative 'tasks/exec'
+require_relative 'tasks/mysql'
+require_relative 'tasks/ops'
+require_relative 'tasks/plugin'
+require_relative 'tasks/redis'
+require_relative 'tasks/seed'
+require_relative 'tasks/self'
+require_relative 'tasks/shell_init'
+require_relative 'tasks/system'
+require_relative 'tasks/system/completions'
+require_relative 'tasks/tools'
+require_relative 'tasks/vm'

data/lib/hem/tasks/deps.rb

@@ -4,7 +4,7 @@ namespace :deps do
 
   desc "Install Gem dependencies"
   task :gems do
-    locate "*Gemfile" do
+    locate "Gemfile" do
       required = shell("bundle check", :exit_status => true) != 0
       if required
         Hem.ui.title "Installing Gem dependencies"
@@ -46,7 +46,7 @@ namespace :deps do
         end
 
         if !complete
-          run_command *args
+          run *args
         end
 
         Hem.ui.success "Composer dependencies installed"
@@ -57,10 +57,9 @@ namespace :deps do
   end
 
   desc "Install vagrant plugins"
-  task :vagrant_plugins => [ "deps:gems" ] do
-    require 'semantic'
-    plugins = shell "vagrant plugin list", :capture => true
-    locate "*Vagrantfile" do
+  task :vagrant_plugins do
+    raw_plugins = shell "vagrant plugin list", :capture => true
+    locate "Vagrantfile" do
       to_install = {}
       File.read("Vagrantfile").split("\n").each do |line|
         if line.match(/#\s*(?:Hem|Hobo)\.(vagrant_plugin.*)/)
@@ -73,18 +72,18 @@ namespace :deps do
       end
 
       plugins = Hash[
-        plugins.scan(/^([^\s]+)\s+\(([^,\)]+)(?:,[^\)]+)?\)$/).map do |plugin, version|
-          [plugin, Semantic::Version.new(version)]
+        raw_plugins.scan(/^([^\s]+)\s+\(([^,\)]+)(?:,[^\)]+)?\)$/).map do |plugin, version|
+          [plugin, version]
         end
       ]
 
       to_install.each do |plugin, constraint|
-        next if plugins.has_key?(plugin) && (constraint.nil? || plugins[plugin].satisfies(constraint))
-        Hem.ui.title "Installing vagrant plugin: #{plugin}#{constraint && " #{constraint}"}"
+        next if plugins.has_key?(plugin) && (constraint.nil? || constraint.match?(plugin, plugins[plugin]))
+        Hem.ui.title "Installing vagrant plugin: #{plugin}#{constraint.nil? ? '' : " #{constraint.requirement.to_s}"}"
         args = ["vagrant", "plugin", "install", plugin]
         if constraint
           args << '--plugin-version'
-          args << constraint
+          args << constraint.requirement.to_s
         end
         shell *args, :realtime => true, :indent => 2
         Hem.ui.separator
@@ -94,7 +93,7 @@ namespace :deps do
 
   desc "Install chef dependencies"
   task :chef => [ "deps:gems" ] do
-    locate "*Cheffile" do
+    locate "Cheffile" do
       Hem.ui.title "Installing chef dependencies via librarian"
       bundle_shell "librarian-chef", "install", "--verbose", :realtime => true, :indent => 2 do |line|
         line =~ /Installing.*</ ? line.strip + "\n" : nil
@@ -102,9 +101,9 @@ namespace :deps do
       Hem.ui.separator
     end
 
-    locate "*Berksfile" do
+    locate "Berksfile" do
       Hem.ui.title "Installing chef dependencies via berkshelf"
-      executor = (shell("bash -c 'which berks'", :capture => true).strip =~ /chefdk/) ?
+      executor = (shell("bundle show berkshelf", exit_status: true) > 0) ?
         lambda { |*args| shell *args } :
         lambda { |*args| bundle_shell *args }
 

data/lib/hem/tasks/exec.rb

@@ -1,3 +1,5 @@
-task 'exec' do
-  exec(*$HEM_ARGV)
+argument :command
+argument 'args', optional: true, default: {}, as: Array
+task 'exec' do |task, args|
+  exec [args[:command], args[:command]], *args[:args]
 end

data/lib/hem/tasks/magento.rb

@@ -1,281 +1,19 @@
-namespace :tools do
-  desc "Fetches the n98-magerun utility"
-  task :n98magerun do
-    FileUtils.mkdir_p "bin"
-    run_command '"wget" --no-check-certificate "https://raw.github.com/netz98/n98-magerun/master/n98-magerun.phar" -O bin/n98-magerun.phar'
-    FileUtils.chmod 0755, "bin/n98-magerun.phar"
-  end
+unless defined? HOBO_TASKS_MAGENTO_DEPRECATION
+Hem.ui.warning "require 'hem/tasks/magento' in #{Hem.project_dsl_file} is deprecated, and will be removed in a future release."
 end
 
-desc "Magento related tasks"
-namespace :magento do
+Hem.ui.warning <<-eos
+Please replace with:
 
-  desc "Patch tasks"
-  namespace :patches do
-    def magento_path
-      unless @magento_path
-        files = locate('*app/Mage.php')
-        unless files.length > 0
-          raise Hem::UserError.new "Could not find app/Mage.php in the git repository, this command should only be run for Magento projects"
-        end
+Hem.require_version '~> 1.1'
 
-        /(?:(.*)\/)app\/Mage\.php/.match(files[0])
-        @magento_path = $1
-      end
-      @magento_path
-    end
-
-    def detect_clean
-      status = shell('git status -z', :capture => true, :strip => false)
-      status.split("\u0000").each do |line|
-        match = line.match(/^([\s\S]{2})\s+(.*)$/)
-        next if match.nil?
-
-        if ![' ', '?'].include?($1[0]) || $2.start_with?(magento_path)
-          raise Hem::UserError.new "Please remove all files from the git index, and stash all changes in '#{magento_path}' before continuing"
-        end
-      end
-    end
-
-    def detect_version
-      config_dirty = false
-      magento_version_file = "#{magento_path}/app/Mage.php"
-
-      if Hem.project_config[:magento_edition].nil?
-        magento_edition = nil
-        if magento_version_file
-          args = [ "php -r \"require '#{magento_version_file}'; echo Mage::getEdition();\""]
-
-          magento_edition = run_command(*args, :capture => true).to_s.downcase
-        end
-
-        edition_options = ['community', 'enterprise', 'professional', 'go']
-
-        unless edition_options.include? magento_edition
-          raise Hem::Error.new "Invalid Magento edition '#{magento_edition}' was found when calling Mage::getEdition(), skipping patches"
-        end
-
-        Hem.project_config[:magento_edition] = magento_edition
-        config_dirty = true
-      end
-
-      if Hem.project_config[:magento_version].nil?
-        magento_version = nil
-        if magento_version_file
-          args = [ "php -r \"require '#{magento_version_file}'; echo Mage::getVersion();\""]
-
-          magento_version = run_command(*args, :capture => true)
-        end
-
-        version_regex = /^\d+(\.\d+){3}$/
-
-        unless version_regex.match(magento_version)
-          raise Hem::Error.new "Invalid Magento version '#{magento_version}' was found when calling Mage::getVersion(), skipping patches"
-        end
-
-        Hem.project_config[:magento_version] = magento_version
-        config_dirty = true
-      end
-
-      if config_dirty
-        Hem::Config::File.save(Hem.project_config_file, Hem.project_config)
-      end
-    end
-
-    def detect_tools
-      use_vm = shell("which which", :exit_status => true) != 0
-
-      tools = ['patch', 'sed']
-      tools_command = tools.map {|tool| "which #{tool}"}.join " && "
-      status = 0
-
-      unless use_vm
-        status = shell(tools_command, :exit_status => true)
-        use_vm = status != 0
-      end
-
-      if use_vm
-        status = run_command(tools_command, :exit_status => true)
-      end
-
-      if status != 0
-        raise Hem::UserError.new "Please make sure '#{tools.join(',')}' is installed on your host or VM before continuing"
-      end
-
-      use_vm
-    end
-
-    desc "Apply patches to Magento"
-    task "apply" do
-      detect_clean
-      detect_version
-
-      config = Hem.project_config
-
-      sync = Hem::Lib::S3::Sync.new(Hem.aws_credentials)
-
-      patches_path = "#{Hem.project_path}/tools/patches"
-      incoming_path = "#{patches_path}/incoming"
-
-      Hem.ui.success("Downloading Magento #{config[:magento_edition].capitalize} #{config[:magento_version]} patches")
-      changes = sync.sync(
-        "s3://inviqa-assets-magento/#{config[:magento_edition]}/patches/#{config[:magento_version]}/",
-        "#{incoming_path}/",
-        :delete => false
-      )
-      Hem.ui.separator
-
-      use_vm = false
-      use_vm = detect_tools if Dir.glob("#{incoming_path}/*.sh").length > 0
-
-      patch_files = Dir.glob("#{incoming_path}/*.{sh,patch,diff}")
-
-      Hem.ui.success("#{patch_files.length} new patches found")
-
-      Hem.ui.separator
-
-      patch_files.each do |file|
-        filename = File.basename(file)
-        base_filename = File.basename(filename, File.extname(filename))
-
-        if File.exist?("#{patches_path}/#{filename}")
-          Hem.ui.debug("Patch #{filename} has already been applied, so skipping it")
-
-          File.delete file
-          next
-        end
-
-        if File.exist?("#{patches_path}/#{base_filename}.skip")
-          File.delete file
-          next
-        end
-
-        Hem.ui.success("Applying patch #{filename}")
-
-        yaml_file = File.join(File.dirname(file), base_filename + ".yaml")
-
-        metadata = {
-          'commit_message' => "Apply Magento patch #{filename}"
-        }
-        if File.exist?(yaml_file)
-          metadata = Hem::Config::File.load(yaml_file)
-        end
-
-        Hem.ui.info(metadata['description']) unless metadata['description'].nil?
-
-        patch_options = %w( yes never skip )
-        answer = Hem.ui.ask_choice('Do you want to apply this patch?', patch_options)
-
-        if answer == 'skip'
-          next
-        end
-
-        if answer == 'never'
-          File.delete file
-          File.write("#{patches_path}/#{base_filename}.skip", '')
-
-          shell "git add '#{patches_path}/#{base_filename}.skip'"
-          shell "git commit -m 'Add a skip file for patch #{filename}'"
-          next
-        end
-
-        if /\.sh$/.match(file)
-          File.rename file, "#{magento_path}/#{filename}"
-          file = "#{magento_path}/#{filename}"
-          if use_vm
-            run_command "cd #{magento_path} && sh #{filename}", :realtime => true, :indent => 2
-          else
-            shell "cd #{magento_path} && sh #{filename}", :realtime => true, :indent => 2
-          end
-        else
-          shell "git apply --directory #{magento_path} #{file}"
-        end
-        File.rename file, "#{patches_path}/#{filename}"
-        shell "git add #{magento_path}"
-        shell "git add #{patches_path}/#{filename}"
-
-        if File.exist?(yaml_file)
-          yaml_filename = File.basename(yaml_file)
-          File.rename yaml_file, "#{patches_path}/#{yaml_filename}"
-          shell "git add #{patches_path}/#{yaml_filename}"
-        end
-        shell "git commit -m #{metadata['commit_message'].shellescape}"
-
-        Hem.ui.separator
-      end
-
-      Hem.ui.success("Finished applying #{patch_files.length} patches")
-    end
-  end
-
-  desc "Setup script tasks"
-  namespace :'setup-scripts' do
-    desc "Run magento setup scripts"
-    task :run => ['tools:n98magerun']  do
-      Hem.ui.success "Running setup scripts"
-      run_command("bin/n98-magerun.phar cache:clean config", :realtime => true, :indent => 2)
-      run_command("bin/n98-magerun.phar sys:setup:incremental -n", :realtime => true, :indent => 2)
-      Hem.ui.separator
-    end
-  end
-
-  desc "Cache tasks"
-  namespace :cache do
-    desc "Clear cache"
-    task :clear => ['tools:n98magerun']  do
-      Hem.ui.success "Clearing magento cache"
-      run_command("bin/n98-magerun.phar cache:flush", :realtime => true, :indent => 2)
-      Hem.ui.separator
-    end
-  end
-
-  desc "Configuration related tasks"
-  namespace :config do
-    desc "Configure magento base URLs"
-    task :'configure-urls' => ['tools:n98magerun'] do
-      Hem.ui.success "Configuring magento base urls"
-      domain = Hem.project_config.hostname
-      run_command("bin/n98-magerun.phar config:set web/unsecure/base_url 'http://#{domain}/'", :realtime => true, :indent => 2)
-      run_command("bin/n98-magerun.phar config:set web/secure/base_url 'https://#{domain}/'", :realtime => true, :indent => 2)
-      Hem.ui.separator
-    end
-
-    desc "Enable magento errors"
-    task :'enable-errors' do
-      error_config = File.join(Hem.project_path, 'public/errors/local.xml')
-
-      FileUtils.cp(
-          error_config + ".sample",
-          error_config
-      ) unless File.exists? error_config
-    end
-
-    desc "Create admin user"
-    task :'create-admin-user' do
-      initialized = run_command("bin/n98-magerun.phar admin:user:list | grep admin", :exit_status => true) == 0
-      unless initialized
-        Hem.ui.success "Creating admin user"
-        run_command("bin/n98-magerun.phar admin:user:create admin '' admin admin admin", :realtime => true, :indent => 2)
-        Hem.ui.separator
-      end
-    end
-
-    desc "Enable rewrites"
-    task :'enable-rewrites' do
-      Hem.ui.success "Enabling rewrites"
-      run_command("bin/n98-magerun.phar config:set web/seo/use_rewrites 1", :realtime => true, :indent => 2)
-      Hem.ui.separator
-    end
-  end
+plugins do
+  source 'https://rubygems.org'
+  gem 'hem-tasks-magento1', '~> 1.0'
+end
+eos
 
-  desc "Initializes magento specifics on the virtual machine after a fresh build"
-  task :'initialize-vm' => [
-    'magento:config:enable-errors',
-    'tools:n98magerun',
-    'magento:setup-scripts:run',
-    'magento:config:configure-urls',
-    'magento:config:create-admin-user',
-    'magento:config:enable-rewrites',
-    'magento:cache:clear'
-  ]
+plugins do
+  source 'https://rubygems.org'
+  gem 'hem-tasks-magento1', '~> 1.0'
 end