pineapples 0.1.0 → 0.3.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d5ed18a509d099566d64609ab821db288ce0afe8
-  data.tar.gz: b992e9901788c706d83b2c725754c59be5f35c93
+  metadata.gz: 4168dcbfa92187c3d8bcf7b67f594cb7a3308067
+  data.tar.gz: 9fd839446bd1602e213722deb11049aa9cd9c642
 SHA512:
-  metadata.gz: 8cefd568c868fa1950afc8482cde7ac622634e21a8560bfc8b2289ccf017a021b34dd00e0ef7479a125b12cc30081bbd288a98cba2e420b6b2920fb3791b6d6b
-  data.tar.gz: 5bbe87d1fbacc84230db364348e83eb86c4bac7422306786cf752cc798d88bcfb8b127349cf64ef298486da1f2c3d505cef2fda20fd2dd35bf97572af503f6db
+  metadata.gz: 92f8f1dfe6d724cc76085cd4cda7f55c0ba0bb03557292b156310b3613c5afbd70d75537abffc289c513a7280068ba4b2d1f9c3d152f276e8e84867be3279fb5
+  data.tar.gz: fedbe56b5c2475020d96dabe94a904cf4b11ff6c41bf3994a98e3a7724b32ad0b9581d5b3a61613da04d4887f5976452ccf0ba41dba520d8297fba1a11b551dd

data/.gitignore

@@ -1,3 +1,4 @@
+*.gem
 /.bundle/
 /.yardoc
 /Gemfile.lock

data/.rspec

@@ -1,2 +1,3 @@
+--require spec_helper
 --format documentation
 --color

data/.ruby-gemset

@@ -0,0 +1 @@
+pineapples

data/bin/pineapples

@@ -6,13 +6,8 @@ $LOAD_PATH << source_path
 
 require 'pineapples'
 
-if ['create', '--create'].include? ARGV[0]
-  ARGV.shift
-  puts "[WARNING] the suspenders create argument is deprecated. Just use `suspenders #{ARGV.join}` instead"
-end
+$terminal.indent_size = 2
 
-templates_root = File.expand_path(File.join('..', 'templates'), File.dirname(__FILE__))
-Pineapples::AppGenerator.source_root templates_root
-Pineapples::AppGenerator.source_paths << Rails::Generators::AppGenerator.source_root << templates_root
-
-Pineapples::AppGenerator.start
+options = Pineapples::Parser.parse(ARGV)
+generator = Pineapples::AppGenerator.new(options)
+generator.start!

data/lib/pineapples/actions/apply.rb

@@ -0,0 +1,34 @@
+module Pineapples
+  module Actions
+    # Loads an external file and execute it in the instance binding.
+    #
+    # ==== Parameters
+    # path<String>:: The path to the file to execute. Can be a web address or
+    #                a relative path from the source root.
+    #
+    # ==== Examples
+    #
+    #   apply "http://gist.github.com/103208"
+    #
+    #   apply "recipes/jquery.rb"
+    #
+    def apply(path, options = {})
+      verbose = options.fetch(:verbose, verbose?)
+      is_uri  = path =~ %r{^https?\://}
+      path    = find_in_source_paths(path) if !is_uri
+      color   = options.fetch(:color, DEFAULT_COLOR)
+
+      say_status(:apply, path, color, verbose)
+
+      indent(verbose) do
+        if is_uri
+          contents = open(path, 'Accept' => 'application/x-thor-template') { |io| io.read }
+        else
+          contents = open(path) { |io| io.read }
+        end
+
+        instance_eval(contents, path)
+      end
+    end
+  end
+end

data/lib/pineapples/actions/base/action.rb

@@ -0,0 +1,72 @@
+module Pineapples
+  module Actions
+    class Action
+      STATUS_COLORS = {creative: :light_green,
+                       destructive: :light_red,
+                       neutral: :light_blue,
+                       warning: :light_yellow}
+
+      # Reference to AppGenerator instance
+      attr_reader :generator
+
+      attr_reader :colors
+
+      # Options hash
+      attr_accessor :options
+
+      # Let status colors set by .status_color macro be inherited
+      def self.inherited(child_class)
+        super
+        child_class.instance_variable_set('@colors', self.colors)
+      end
+
+      def self.status_color(status, color)
+        colors[status] = color
+      end
+
+      def self.colors
+        @colors ||= {}
+      end
+
+      def initialize(generator, options = {})
+        @generator = generator
+        @options = options
+      end
+
+      def invoke!
+        raise NotImplementedError, "You should really implement invoke! method on Action subclasses"
+      end
+
+      def skip?
+        @skip = false if @skip.nil?
+        @skip
+      end
+
+      protected
+
+      def pretend?
+        generator.pretend?
+      end
+
+      def execute?
+        !pretend?
+      end
+
+      def verbose?
+        options[:verbose] || generator.verbose?
+      end
+
+      # used to log action actions (no pun intended)
+      def say_status(status, message = self.message, color = nil)
+        color = color(status) if color.nil?
+        generator.say_status(status, message, color) if verbose?
+      end
+
+      def color(status)
+        color = self.class.colors[status]
+        color = STATUS_COLORS[color] if STATUS_COLORS.keys.include?(color)
+      end
+
+    end
+  end
+end

data/lib/pineapples/actions/base/target.rb

@@ -0,0 +1,136 @@
+module Pineapples
+  module Actions
+    class Target
+      PASS_MATCH  = /!=(.*?)!/
+      GUARD_MATCH = /!(.*?)!/
+      EVAL_MATCH  = /%(.*?)%/
+
+      attr_reader :given,
+                  :fullpath,
+                  :relative,
+                  :action
+
+      def initialize(target, action)
+        raise Error, 'Target should not be falsy' if !target
+
+        @action = action
+        @given = target.to_s
+
+        evaluate_pass_method!
+        evaluate_guard_methods!
+        evaluate_filename_method!
+
+        @fullpath = File.expand_path(@given, generator.current_app_dir)
+        @relative = generator.relative_to_current_app_dir(@fullpath)
+      end
+
+      def generator
+        action.generator
+      end
+
+      def skip?
+        @skip = false if @skip.nil?
+        @skip
+      end
+
+      private
+
+      def evaluate_pass_method!
+        if pass_match
+          raise Error, methods_missing_error_message(pass_methods) if !generator_pass_method
+
+          @skip = !generator.send(generator_pass_method)
+          @given.gsub!(pass_match[0], '')
+        end
+      end
+
+      def evaluate_guard_methods!
+        if guard_match
+          raise Error, methods_missing_error_message(guard_methods) if !generator_guard_method
+
+          @skip = generator.send(generator_guard_method)
+          @given.gsub!(guard_match[0], '')
+        end
+      end
+
+      def evaluate_filename_method!
+        if eval_match
+          raise Error, methods_missing_error_message(filename_method) if !generator_filename_method
+
+          filename = generator.send(filename_method)
+          @given.gsub!(eval_match[0], filename)
+        end
+      end
+
+      def pass_match
+        PASS_MATCH.match(@given)
+      end
+
+      def guard_match
+        GUARD_MATCH.match(@given)
+      end
+
+      def eval_match
+        EVAL_MATCH.match(@given)
+      end
+
+      def generator_pass_method
+        if @pass_method.nil?
+          pass_methods.each do |method|
+            if generator.respond_to?(method, true)
+              @pass_method = method
+              break
+            end
+          end
+        end
+        @pass_method = false if @pass_method.nil?
+        @pass_method
+      end
+
+      def generator_guard_method
+        if @guard_method.nil?
+          guard_methods.each do |method|
+            if generator.respond_to?(method, true)
+              @guard_method = method
+              break
+            end
+          end
+        end
+        @guard_method = false if @guard_method.nil?
+        @guard_method
+      end
+
+      def generator_filename_method
+        if @filename_method.nil?
+          @filename_method = generator.respond_to?(filename_method, true) ? filename_method : false
+        end
+        @filename_method
+      end
+
+      def guard_methods
+        guard_method = guard_match[1].strip
+        predicate_method = guard_method + '?'
+        [guard_method, predicate_method]
+      end
+
+      def pass_methods
+        pass_method = pass_match[1].strip
+        predicate_method = pass_method + '?'
+        [pass_method, predicate_method]
+      end
+
+      def filename_method
+        eval_match[1].strip
+      end
+
+      def methods_missing_error_message(methods)
+        plural = methods.is_a?(Array)
+        methods = methods.join(', ') if plural
+        methods_message = plural ? 'methods' : 'method'
+
+        "No instance #{methods_message} #{methods} for AppGenerator, can't evaluate filepath #{given}"
+      end
+    end
+
+  end
+end

data/lib/pineapples/actions/chmod.rb

@@ -0,0 +1,28 @@
+module Pineapples
+  module Actions
+    # Changes the mode of the given file or directory.
+    #
+    # ==== Parameters
+    # mode<Integer>:: the file mode
+    # path<String>:: the name of the file to change mode
+    # options<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Example
+    #
+    #   chmod "script/server", 0755
+    #
+    def chmod(path, mode, options = {})
+      return unless behaviour == :invoke
+
+      verbose = options.fetch(:verbose, verbose?)
+      execute = !options.fetch(:pretend, pretend?)
+      color   = options.fetch(:color, DEFAULT_COLOR)
+
+      relative_path = relative_to_app_root(File.join(app_root, path))
+
+      say_status(:chmod, relative_path, color, verbose)
+
+      FileUtils.chmod_R(mode, path) if execute
+    end
+  end
+end

data/lib/pineapples/actions/copy_file.rb

@@ -0,0 +1,48 @@
+require_relative 'create_file'
+
+module Pineapples
+  module Actions
+    # Copies the file from the relative source to the relative destination. If
+    # the destination is not given it's assumed to be equal to the source.
+    #
+    # ==== Parameters
+    # source<String>:: the relative path to the source root.
+    # target<String>:: the relative path to the destination root.
+    # options<Hash>:: give :verbose => false to not log the status, and
+    #                :mode => :preserve, to preserve the file mode from the source.
+
+    #
+    # ==== Examples
+    #
+    #   copy_file "README", "doc/README"
+    #
+    #   copy_file "doc/README"
+    #
+    def copy_file(source, *args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      target = args.first || source
+
+      action CopyFile.new(self, source, target, options, &block)
+    end
+
+    class CopyFile < CreateFile
+      attr_reader :source
+
+      def initialize(generator, source, target, options, &block)
+        @source  = File.expand_path(generator.find_in_source_paths(source.to_s))
+        @content = File.binread(@source)
+        @content = block.call(@content) if block
+        super(generator, target, @content, options)
+      end
+
+      def invoke!
+        super
+        if options[:mode] == :preserve
+          mode = File.stat(source).mode
+          generator.chmod(target, mode, options)
+        end
+      end
+
+    end
+  end
+end

data/lib/pineapples/actions/create_file.rb

@@ -0,0 +1,114 @@
+require_relative 'empty_directory'
+
+module Pineapples
+  module Actions
+    # Create a new file relative to the destination root with the given data,
+    # which is the return value of a block or a data string.
+    #
+    # ==== Parameters
+    # target<String>:: the relative path to the destination root.
+    # content<String|NilClass>:: the data to append to the file.
+    # options<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Examples
+    #
+    #   create_file "lib/fun_party.rb" do
+    #     hostname = ask("What is the virtual hostname I should use?")
+    #     "vhost.name = #{hostname}"
+    #   end
+    #
+    #   create_file "config/apache.conf", "your apache config"
+    #
+    def create_file(target, *args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      content = args.first
+      action CreateFile.new(self, target, block || content, options)
+    end
+
+    def ask_file_collision(target) # rubocop:disable MethodLength
+      return true if @always_force
+      options = '[Ynaq]'
+
+      question_string = "Overwrite #{target}?"
+      options = ['Yes', 'No', 'Always', 'Quit']
+      colors = [:light_green, :light_red, :light_yellow, :light_red]
+      options_with_color = options.map.with_index { |option, index| option.send(colors[index])}
+
+      loop do
+        answer_index = Ask.list(question_string, options_with_color, {clear: false, response: false})
+        answer = options[answer_index]
+
+        case answer
+        when 'Yes'
+          return true
+        when 'No'
+          return false
+        when 'Always'
+          return @always_force = true
+        when 'Quit'
+          say 'Aborting'
+          raise SystemExit
+        end
+      end
+    end
+
+    class CreateFile < EmptyDirectory
+      attr_reader :content
+
+      status_color :identical, :neutral
+      status_color :force, :warning
+      status_color :skip, :warning
+      status_color :conflict, :destructive
+
+      def initialize(generator, target, content, options = {})
+        super(generator, target, options)
+        @content = content
+      end
+
+      def identical?
+        exists? && File.binread(target.fullpath) == render
+      end
+
+      def render
+        @render ||= content.is_a?(Proc) ? content.call : content.to_s
+      end
+
+      def invoke!
+        invoke_with_conflict_check do
+          FileUtils.mkdir_p(File.dirname(target.fullpath))
+          File.open(target.fullpath, 'wb') { |file| file.write render }
+        end
+        target.given
+      end
+
+      protected
+
+      def on_conflict_behaviour(&block)
+        if identical?
+          say_status :identical
+        else
+          force_or_skip_or_conflict(options[:force], options[:skip], &block)
+        end
+      end
+
+      def force_or_skip_or_conflict(force, skip, &block)
+        if force
+          say_status :force
+          block.call if execute?
+        elsif skip
+          say_status :skip
+        else
+          say_status :conflict
+          force_or_skip_or_conflict(force_on_collision?, true, &block)
+        end
+      end
+
+      # Shows the file collision menu to the user and gets the result.
+      #
+      def force_on_collision?
+        generator.ask_file_collision(target)
+      end
+
+    end
+  end
+end

data/lib/pineapples/actions/directory.rb

@@ -0,0 +1,115 @@
+module Pineapples
+  module Actions
+    # Copies recursively the files from source directory to root directory.
+    # If any of the files finishes with .tt, it's considered to be a template
+    # and is placed in the destination without the extension .tt. If any
+    # empty directory is found, it's copied and all .empty_directory files are
+    # ignored. If any file name is wrapped within % signs, the text within
+    # the % signs will be executed as a method and replaced with the returned
+    # value. Let's suppose a doc directory with the following files:
+    #
+    #   doc/
+    #     components/.empty_directory
+    #     README
+    #     rdoc.rb.tt
+    #     %app_name%.rb
+    #
+    # When invoked as:
+    #
+    #   directory "doc"
+    #
+    # It will create a doc directory in the destination with the following
+    # files (assuming that the `app_name` method returns the value "blog"):
+    #
+    #   doc/
+    #     components/
+    #     README
+    #     rdoc.rb
+    #     blog.rb
+    #
+    # ==== Parameters
+    # source<String>:: the relative path to the source root.
+    # target<String>:: the relative path to the destination root.
+    # options<Hash>:: give :verbose => false to not log the status.
+    #                If :recursive => false, does not look for paths recursively.
+    #                If :mode => :preserve, preserve the file mode from the source.
+    #                If :exclude_pattern => /regexp/, prevents copying files that match that regexp.
+    #
+    # ==== Examples
+    #
+    #   directory "doc"
+    #   directory "doc", "docs", :recursive => false
+    #
+    def directory(source, *args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      target = args.first || source
+      action Directory.new(self, source, target, options, &block)
+    end
+
+    class Directory < EmptyDirectory
+      attr_reader :source
+
+      def initialize(generator, source, target, options, &block)
+        super(generator, target, {recursive: true}.merge(options))
+
+        @source = File.expand_path(generator.find_in_source_paths(source.to_s))
+        @block  = block
+      end
+
+      def invoke!
+        generator.empty_directory(target.given, options)
+        execute!
+      end
+
+      def revoke!
+        execute!
+      end
+
+      protected
+
+      def execute!
+        lookup = escape_globs(source)
+        lookup = options[:recursive] ? File.join(lookup, '**') : lookup
+        lookup = file_level_lookup(lookup)
+
+        excluded_files = Array(options[:exclude])
+        exclude_pattern = options[:exclude_pattern]
+
+        files(lookup).sort.each do |file_source|
+          next if File.directory?(file_source)
+          next if exclude_pattern && file_source.match(exclude_pattern)
+          next if excluded_files.any? do |excluded_file|
+            File.basename(excluded_file) == File.basename(file_source)
+          end
+
+          file_target = File.join(target.given, file_source.gsub(source, '.'))
+          file_target.gsub!('/./', '/')
+
+          case file_source
+          when /\.empty_directory$/
+            dirname = File.dirname(file_target).gsub(/\/\.$/, '')
+            next if dirname == target.given
+            generator.empty_directory(dirname, options)
+          when /#{TEMPLATE_EXTNAME}$/
+            generator.template(file_source, file_target[0..-4], options, &@block)
+          else
+            generator.copy_file(file_source, file_target, options, &@block)
+          end
+        end
+      end
+
+      def file_level_lookup(previous_lookup)
+        File.join(previous_lookup, '*')
+      end
+
+      def files(lookup)
+        Dir.glob(lookup, File::FNM_DOTMATCH)
+      end
+
+      def escape_globs(path)
+        path.to_s.gsub(/[*?{}\[\]]/, '\\\\\\&')
+      end
+    end
+
+  end
+end

data/lib/pineapples/actions/empty_directory.rb

@@ -0,0 +1,71 @@
+module Pineapples
+  module Actions
+    # Creates an empty directory.
+    #
+    # ==== Parameters
+    # target<String>:: the relative path to the app root.
+    # options<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Examples
+    #
+    #   empty_directory "doc"
+    #
+    def empty_directory(target, options = {})
+      action EmptyDirectory.new(self, target, options)
+    end
+
+    class EmptyDirectory < Action
+      attr_reader :target,
+                  :skip
+
+      status_color :create, :creative
+      status_color :remove, :destructive
+      status_color :exist,  :neutral
+
+      def initialize(generator, target, options = {})
+        super(generator, options)
+
+        @target = Target.new(target, self)
+        @skip = @target.skip?
+      end
+
+      def invoke!
+        invoke_with_conflict_check do
+          ::FileUtils.mkdir_p(target.fullpath)
+        end
+      end
+
+      def revoke!
+        say_status :remove
+        ::FileUtils.rm_rf(target.fullpath) if execute? && exists?
+        given_target
+      end
+
+      def exists?
+        ::File.exist?(target.fullpath)
+      end
+
+      protected
+
+      def invoke_with_conflict_check(&block)
+        if exists?
+          on_conflict_behaviour(&block)
+        else
+          say_status :create
+          block.call if execute?
+        end
+
+        target.fullpath
+      end
+
+      def on_conflict_behaviour(&block)
+        say_status :exist
+      end
+
+      def message
+        target.relative
+      end
+
+    end
+  end
+end