pineapples 0.1.0 → 0.3.34

data/lib/pineapples/actions/get.rb

@@ -0,0 +1,38 @@
+require 'open-uri'
+
+module Pineapples
+  module Actions
+    # Gets the content at the given address and places it at the given relative
+    # destination. If a block is given instead of destination, the content of
+    # the url is yielded and used as location.
+    #
+    # ==== Parameters
+    # source<String>:: the address of the given content.
+    # target<String>:: the relative path to the destination root.
+    # options<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Examples
+    #
+    #   get "http://gist.github.com/103208", "doc/README"
+    #
+    #   get "http://gist.github.com/103208" do |content|
+    #     content.split("\n").first
+    #   end
+    #
+    def get(source, *args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      target = args.first
+
+      source = File.expand_path(find_in_source_paths(source.to_s)) unless source =~ %r{^https?\://}
+      render = open(source) { |input| input.binmode.read }
+
+      target ||= if block
+                   block.arity == 1 ? block.call(render) : block.call
+                 else
+                   File.basename(source)
+                 end
+
+      create_file(target, render, options)
+    end
+  end
+end

data/lib/pineapples/actions/git.rb

@@ -0,0 +1,17 @@
+module Pineapples
+  module Actions
+    # Run a command in git.
+    #
+    #   git :init
+    #   git add: "this.file that.rb"
+    #   git add: "onefile.rb", rm: "badfile.cxx"
+    def git(commands = {})
+      if commands.is_a?(Symbol)
+        shell "git #{commands}"
+      else
+        commands.each { |cmd, options| shell "git #{cmd} #{options}" }
+      end
+    end
+
+  end
+end

data/lib/pineapples/actions/gsub_file.rb

@@ -0,0 +1,36 @@
+module Pineapples
+  module Actions
+    # Run a regular expression replacement on a file.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # flag<Regexp|String>:: the regexp or string to be replaced
+    # replacement<String>:: the replacement, can be also given as a block
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Example
+    #
+    #   gsub_file 'app/controllers/application_controller.rb', /#\s*(filter_parameter_logging :password)/, '\1'
+    #
+    #   gsub_file 'README', /rake/, :green do |match|
+    #     match << " no more. Use thor!"
+    #   end
+    #
+    def gsub_file(path, flag, *args, &block)
+      return unless behaviour == :invoke
+      options = args.last.is_a?(Hash) ? args.pop : {}
+
+      verbose = options.fetch(:verbose, verbose?)
+      execute = options.fetch(:pretend, execute?)
+
+      path = File.expand_path(path, app_root)
+      say_status :gsub, relative_to_app_root(path), :light_yellow, verbose
+
+      if execute
+        content = File.binread(path)
+        content.gsub!(flag, *args, &block)
+        File.open(path, 'wb') { |file| file.write(content) }
+      end
+    end
+  end
+end

data/lib/pineapples/actions/insert_into_file.rb

@@ -0,0 +1,131 @@
+module Pineapples
+  module Actions
+    def insert_into_file(target, *args, &block)
+      content = block_given? ? block : args.shift
+      options = args.shift
+      action InsertIntoFile.new(self, target, content, options)
+    end
+
+    # Append text to a file. Since it depends on insert_into_file, it's reversible.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # data<String>:: the data to append to the file, can be also given as a block.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Example
+    #
+    #   append_to_file 'config/environments/test.rb', 'config.gem "rspec"'
+    #
+    #   append_to_file 'config/environments/test.rb' do
+    #     'config.gem "rspec"'
+    #   end
+    #
+    def append_to_file(path, *args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      options.merge!(before: /\z/)
+      insert_into_file(path, *(args << options), &block)
+    end
+    alias_method :append_file, :append_to_file
+
+    # Prepend text to a file. Since it depends on insert_into_file, it's reversible.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # content<String>:: the content to prepend to the file, can be also given as a block.
+    # options<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Example
+    #
+    #   prepend_to_file 'config/environments/test.rb', 'config.gem "rspec"'
+    #
+    #   prepend_to_file 'config/environments/test.rb' do
+    #     'config.gem "rspec"'
+    #   end
+    #
+    def prepend_to_file(path, *args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      options.merge!(after: /\A/)
+      insert_into_file(path, *(args << options), &block)
+    end
+    alias_method :prepend_file, :prepend_to_file
+
+    class InsertIntoFile < EmptyDirectory
+      attr_reader :new_content,
+                  :flag,
+                  :behaviour
+
+      status_color :prepend,   :creative
+      status_color :append,    :creative
+      status_color :insert,    :creative
+      status_color :substract, :destructive
+
+      def initialize(generator, target, new_content, options)
+        super(generator, target, {verbose: true}.merge(options))
+
+        @behaviour = @options.key?(:after) ? :after : :before
+        @flag = @options.delete(@behaviour)
+
+        @new_content = new_content.is_a?(Proc) ? new_content.call : new_content
+        @flag = Regexp.escape(@flag) if !@flag.is_a?(Regexp)
+      end
+
+      def invoke!
+        say_status status(:invoke)
+
+        content = if @behavior == :after
+                    '\0' + replacement
+                  else
+                    replacement + '\0'
+                  end
+
+        regexp = /#{flag}/
+
+        replace!(regexp, content, options[:force])
+      end
+
+      def revoke!
+        say_status status(:revoke)
+
+        if @behavior == :after
+          content = '\1\2'
+          regexp = /(#{flag})(.*)(#{Regexp.escape(new_content)})/m
+        else
+          content = '\2\3'
+          regexp = /(#{Regexp.escape(new_content)})(.*)(#{flag})/m
+        end
+
+        replace!(regexp, content, true)
+      end
+
+
+
+      protected
+
+      def status(execution_style)
+        if execution_style == :invoke
+          if flag == /\A/
+            :prepend
+          elsif flag == /\z/
+            :append
+          else
+            :insert
+          end
+        else
+          :subtract
+        end
+      end
+
+      def replace!(regexp, string, force)
+        if execute?
+          content = File.binread(target.fullpath)
+          if force || !content.include?(new_content)
+            content.gsub!(regexp, string)
+            File.open(target.fullpath, 'wb') { |file| file.write(content) }
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/pineapples/actions/inside.rb

@@ -0,0 +1,69 @@
+module Pineapples
+  module Actions
+    def dir_stack
+      @dir_stack ||= []
+    end
+
+    def current_app_dir
+      File.expand_path(File.join(*dir_stack), app_root)
+    end
+
+    # Do something in the root or on a provided subfolder. The full path to
+    # the directory is yielded to the block you provide.
+    # The path is set back to the previous path when the method exits.
+    #
+    # ==== Parameters
+    # dir<String>:: the directory to move to, relative to the app root
+    # config<Hash>:: give :verbose => true to log and use padding.
+    #
+    def inside(dir = :root, options = {}, &block)
+      verbose = options.fetch(:verbose, verbose?)
+      color = options.fetch(:color, :light_green)
+
+      status_dir = if dir == :root
+                     relative_to_app_root(app_root)
+                   else
+                     relative_to_app_root(File.join(current_app_dir, dir))
+                   end
+
+      say_status(:inside, status_dir, color, verbose)
+
+      indent(verbose) do
+        with_directory(dir) do |target_dir|
+          if !File.exist?(target_dir) && !pretend?
+            FileUtils.mkdir_p(target_dir)
+          end
+
+          if pretend?
+            block.arity == 1 ? yield(target_dir) : yield
+          else
+            FileUtils.cd(target_dir) do
+              block.arity == 1 ? yield(target_dir) : yield
+            end
+          end
+        end
+      end
+    end
+
+    # Convenience method to call inside in_root
+    def in_root(options = {})
+      inside(:root, options) { yield }
+    end
+
+    private
+
+    # helper method to abstract directory stack management in the "inside" action
+    def with_directory(dir)
+      not_in_root = (dir != :root)
+
+      dir_stack.push(dir) if not_in_root
+
+      target_dir = not_in_root ? current_app_dir : app_root
+
+      yield target_dir
+
+      dir_stack.pop if not_in_root
+    end
+
+  end
+end

data/lib/pineapples/actions/keep_file.rb

@@ -0,0 +1,15 @@
+require_relative 'empty_directory'
+
+module Pineapples
+  module Actions
+    def empty_directory_with_keep_file(target, options = {})
+      empty_directory(target, options)
+      keep_file(target)
+    end
+
+    def keep_file(target)
+      create_file("#{target}/.keep")
+    end
+
+  end
+end

data/lib/pineapples/actions/prepend_to_class.rb

@@ -0,0 +1,26 @@
+module Pineapples
+  module Actions
+    # Injects text right after the class definition. Since it depends on
+    # insert_into_file, it's reversible.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # klass<String|Class>:: the class to be manipulated
+    # data<String>:: the data to append to the class, can be also given as a block.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Examples
+    #
+    #   prepend_to_class "app/controllers/application_controller.rb", ApplicationController, "  filter_parameter :password\n"
+    #
+    #   prepend_to_class "app/controllers/application_controller.rb", ApplicationController do
+    #     "  filter_parameter :password\n"
+    #   end
+    #
+    def prepend_to_class(path, klass, *args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      options.merge!(after: /class #{klass}\n|class #{klass} .*\n/)
+      insert_into_file(path, *(args << options), &block)
+    end
+  end
+end

data/lib/pineapples/actions/rails/copy_migration.rb

@@ -0,0 +1,67 @@
+require 'pineapples/actions/copy_file'
+
+module Pineapples
+  module Actions
+    module Rails
+      def copy_migration(migration_name, options = {})
+        # TODO: find migration file
+        action CopyMigration.new(self, migration_name, options)
+      end
+
+      class CopyMigration < CopyFile
+        attr_reader :migration_name
+
+        def self.time
+          @time ||= Time.now
+        end
+
+        def self.time=(value)
+          @time = value
+        end
+
+        def initialize(generator, migration_name, options)
+          @generator = generator
+          @migration_name = File.basename(migration_name, File.extname(migration_name))
+
+          set_source_for_migration!
+          @target = target_for_migration
+
+          super(generator, @source, @target, options)
+        end
+
+        def invoke!
+          super
+          self.class.time = self.class.time + 2
+        end
+
+        private
+
+        def set_source_for_migration!
+          sources = generator.source_paths_for_search
+
+          sources.each do |source_path|
+            migration_dir = File.join(source_path, relative_migration_dir)
+            Dir.glob("#{migration_dir}/*.rb").each do |filename|
+              @source = filename if filename.include?(migration_name)
+            end
+          end
+
+          raise ArgumentError, "Failed to find migration by name #{migration_name}" if @source.nil?
+        end
+
+        def target_for_migration
+          File.join(relative_migration_dir, "#{migration_timestamp}_#{migration_name}.rb")
+        end
+
+        def relative_migration_dir
+          'db/migrate'
+        end
+
+        def migration_timestamp
+          self.class.time.strftime('%Y%m%d%H%M%S')
+        end
+      end
+
+    end
+  end
+end

data/lib/pineapples/actions/rails/erb_converters.rb

@@ -0,0 +1,37 @@
+module Pineapples
+  module Actions
+    module Rails
+      def erb2haml(target, options = {})
+        recursive = options.fetch(:recursive, true)
+        verbose = options.fetch(:verbose, verbose?)
+        execute = !options.fetch(:pretend, pretend?)
+
+        description = 'Convert ERB views to HAML'
+        say_action(:erb2haml, description, verbose)
+
+        if execute
+          target_path = File.expand_path(target, app_root)
+          target_path = File.join(target_path, recursive_mask) if recursive
+          shell "find #{target_path} -name \\*.erb -print | sed 'p;s/.erb$/.haml/' | xargs -n2 html2haml",
+                 verbose: false
+        end
+      end
+
+      def erb2slim(target, options = {})
+        recursive = options.fetch(:recursive, true)
+        verbose = options.fetch(:verbose, verbose?)
+        execute = !options.fetch(:pretend, pretend?)
+
+        description = 'Convert ERB views to SLIM'
+        say_action(:erb2slim, description, verbose)
+
+        if execute
+          erb2haml(target, options)
+          target_path = File.expand_path(target, app_root)
+          target_path = File.join(target_path, '**') if recursive
+          shell "haml2slim #{target_path} --delete --trace", verbose: false
+        end
+      end
+    end
+  end
+end

data/lib/pineapples/actions/rails/rails.rb

@@ -0,0 +1,186 @@
+require_relative 'erb_converters'
+require_relative 'copy_migration'
+
+module Pineapples
+  module Actions
+    module Rails
+      # Adds a line inside the Application class for <tt>config/application.rb</tt>.
+      #
+      # If options <tt>:env</tt> is specified, the line is appended to the corresponding
+      # file in <tt>config/environments</tt>.
+      #
+      #   environment do
+      #     "config.autoload_paths += %W(#{config.root}/extras)"
+      #   end
+      #
+      #   environment(nil, env: "development") do
+      #     "config.autoload_paths += %W(#{config.root}/extras)"
+      #   end
+      def environment(content = nil, options = {})
+        sentinel = /class [a-z_:]+ < Rails::Application/i
+        env_file_sentinel = /Rails\.application\.configure do/
+        content = yield if !content && block_given?
+
+        in_root do
+          if options[:env].nil?
+            insert_into_file 'config/application.rb', "\n    #{content}",
+                              after: sentinel, verbose: false
+          else
+            Array(options[:env]).each do |env|
+              insert_into_file "config/environments/#{env}.rb", "\n  #{content}",
+                                after: env_file_sentinel, verbose: false
+            end
+          end
+        end
+      end
+      alias :application :environment
+
+      # Create a new file in the <tt>vendor/</tt> directory. Code can be specified
+      # in a block or a data string can be given.
+      #
+      #   vendor("sekrit.rb") do
+      #     sekrit_salt = "#{Time.now}--#{3.years.ago}--#{rand}--"
+      #     "salt = '#{sekrit_salt}'"
+      #   end
+      #
+      #   vendor("foreign.rb", "# Foreign code is fun")
+      def vendor(filename, content = nil, &block)
+        log :vendor, filename
+        create_file("vendor/#{filename}", content, verbose: false, &block)
+      end
+
+      # Create a new file in the lib/ directory. Code can be specified
+      # in a block or a data string can be given.
+      #
+      #   lib("crypto.rb") do
+      #     "crypted_special_value = '#{rand}--#{Time.now}--#{rand(1337)}--'"
+      #   end
+      #
+      #   lib("foreign.rb", "# Foreign code is fun")
+      def lib(filename, content = nil, &block)
+        say_status :lib, filename, color_from_behaviour
+        create_file("lib/#{filename}", content, verbose: false, &block)
+      end
+
+      # Create a new +Rakefile+ with the provided code (either in a block or a string).
+      #
+      #   rakefile("bootstrap.rake") do
+      #     project = ask("What is the UNIX name of your project?")
+      #
+      #     <<-TASK
+      #       namespace :#{project} do
+      #         task :bootstrap do
+      #           puts "I like boots!"
+      #         end
+      #       end
+      #     TASK
+      #   end
+      #
+      #   rakefile('seed.rake', 'puts "Planting seeds"')
+      def rakefile(filename, content = nil, &block)
+        say_status :lib, filename, color_from_behaviour
+        rake_extention = File.extname(filename) == '.rake'
+        filename = rake_extention ? filename : "#{filename}.rake"
+        create_file("lib/tasks/#{filename}", content, verbose: false, &block)
+      end
+
+      # Create a new initializer with the provided code (either in a block or a string).
+      #
+      #   initializer("globals.rb") do
+      #     data = ""
+      #
+      #     ['MY_WORK', 'ADMINS', 'BEST_COMPANY_EVAR'].each do |const|
+      #       data << "#{const} = :entp\n"
+      #     end
+      #
+      #     data
+      #   end
+      #
+      #   initializer("api.rb", "API_KEY = '123456'")
+      def initializer(filename, content = nil, &block)
+        say_status :initializer, filename, color_from_behaviour
+        create_file("config/initializers/#{filename}", content, verbose: false, &block)
+      end
+
+      # Generate something using a generator from Rails or a plugin.
+      # The second parameter is the argument string that is passed to
+      # the generator or an Array that is joined.
+      #
+      #   generate(:authenticated, "user session")
+      def generate(what, *args)
+        say_status :generate, what, color_from_behaviour
+        arguments = args.flat_map(&:to_s).join(' ')
+
+        in_root { ruby("bin/rails generate #{what} #{arguments}", verbose: false) }
+      end
+
+      # Runs the supplied rake task
+      #
+      #   rake("db:migrate")
+      #   rake("db:migrate", env: "production")
+      #   rake("gems:install", sudo: true)
+      def rake(command, options = {})
+        say_status :rake, command, color_from_behaviour
+        env  = options[:env] || ENV['RAILS_ENV'] || 'development'
+        sudo = options[:sudo] && RbConfig::CONFIG['host_os'] !~ /mswin|mingw/ ? 'sudo ' : ''
+        in_root { shell("#{sudo}rake #{command} RAILS_ENV=#{env}", verbose: false) }
+      end
+
+      # Make an entry in Rails routing file <tt>config/routes.rb</tt>
+      #
+      #   route "root 'welcome#index'"
+      def route(routing_code)
+        say_status :route, routing_code, color_from_behaviour
+        sentinel = /\.routes\.draw do\s*\n/m
+
+        in_root do
+          insert_into_file 'config/routes.rb', "  #{routing_code}\n", {after: sentinel, verbose: false, force: true}
+        end
+      end
+
+      # Registers a callback to be executed after bundle and spring binstubs
+      # have run.
+      #
+      #   after_bundle do
+      #     git add: '.'
+      #   end
+      def after_bundle(&block)
+        @after_bundle_callbacks ||= []
+        @after_bundle_callbacks << block
+      end
+
+      protected
+
+      def color_from_behaviour
+        behaviour == :invoke ? :light_green : :light_red
+      end
+
+      # Surround string with single quotes if there is no quotes.
+      # Otherwise fall back to double quotes
+      def quote(value)
+        return value.inspect unless value.is_a? String
+
+        if value.include?("'")
+          value.inspect
+        else
+          "'#{value}'"
+        end
+      end
+
+      def comment_if(setting = nil)
+        return yield ? '# ' : '' if block_given?
+
+        raise ArgumentError, 'You should provide either setting key or block' if setting.nil?
+        settings[setting].value ? '# ' : ''
+      end
+
+      def comment_if_not(setting = nil)
+        return yield ? '' : '# ' if block_given?
+
+        raise ArgumentError, 'You should provide either setting key or block' if setting.nil?
+        settings[setting].value ? '' : '# '
+      end
+
+    end
+  end
+end

data/lib/pineapples/actions/remove_file.rb

@@ -0,0 +1,28 @@
+module Pineapples
+  module Actions
+    # Removes a file at the given location.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # options<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Example
+    #
+    #   remove_file 'README'
+    #   remove_file 'app/controllers/application_controller.rb'
+    #
+    def remove_file(path, options = {})
+      return unless behaviour == :invoke
+      path  = File.expand_path(path, destination_root)
+
+      message = relative_to_app_root(path)
+      verbose = options.fetch(:verbose, verbose?)
+      color = options.fetch(:color, :light_red)
+      execute = options[:pretend] || execute?
+
+      say_status :remove, message, color, verbose
+      ::FileUtils.rm_rf(path) if execute && File.exist?(path)
+    end
+    alias_method :remove_dir, :remove_file
+  end
+end