rcli 0.1.0

data/lib/core/thor_actions.rb

@@ -0,0 +1,302 @@
+require 'fileutils'
+require 'uri'
+require 'core/actions/file_binary_read'
+
+Dir[File.join(Rcli::GEM_LIB, "actions", "*.rb")].each do |action|
+  require action
+end
+
+class Rcli
+  module Actions
+    attr_accessor :behavior
+
+    def self.included(base) #:nodoc:
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # Hold source paths for one Thor instance. source_paths_for_search is the
+      # method responsible to gather source_paths from this current class,
+      # inherited paths and the source root.
+      #
+      def source_paths
+        @_source_paths ||= []
+      end
+
+      # Stores and return the source root for this class
+      def source_root(path=nil)
+        @_source_root = path if path
+        @_source_root
+      end
+
+      # Returns the source paths in the following order:
+      #
+      #   1) This class source paths
+      #   2) Source root
+      #   3) Parents source paths
+      #
+      def source_paths_for_search
+        paths = []
+        paths += self.source_paths
+        paths << self.source_root if self.source_root
+        paths += from_superclass(:source_paths, [])
+        paths
+      end
+
+      # Add runtime options that help actions execution.
+      #
+      def add_runtime_options!
+        class_option :force, :type => :boolean, :aliases => "-f", :group => :runtime,
+                             :desc => "Overwrite files that already exist"
+
+        class_option :pretend, :type => :boolean, :aliases => "-p", :group => :runtime,
+                               :desc => "Run but do not make any changes"
+
+        class_option :quiet, :type => :boolean, :aliases => "-q", :group => :runtime,
+                             :desc => "Supress status output"
+
+        class_option :skip, :type => :boolean, :aliases => "-s", :group => :runtime,
+                            :desc => "Skip files that already exist"
+      end
+    end
+
+    # Extends initializer to add more configuration options.
+    #
+    # ==== Configuration
+    # behavior<Symbol>:: The actions default behavior. Can be :invoke or :revoke.
+    #                    It also accepts :force, :skip and :pretend to set the behavior
+    #                    and the respective option.
+    #
+    # destination_root<String>:: The root directory needed for some actions.
+    #
+    # def initialize(args=[], options={}, config={})
+    #   pp args
+    #   puts "asdfasdf"
+    #   pp options
+    #   puts "asdfasdf"
+    #   pp config
+    #   puts "asdfasdf"
+    #   self.behavior = case config[:behavior].to_s
+    #     when "force", "skip"
+    #       _cleanup_options_and_set(options, config[:behavior])
+    #       :invoke
+    #     when "revoke"
+    #       :revoke
+    #     else
+    #       :invoke
+    #   end
+    # 
+    #   super
+    #   self.destination_root = config[:destination_root]
+    # end
+
+    # Wraps an action object and call it accordingly to the thor class behavior.
+    #
+    def action(instance) #:nodoc:
+      if behavior == :revoke
+        instance.revoke!
+      else
+        instance.invoke!
+      end
+    end
+
+    # Returns the root for this thor class (also aliased as destination root).
+    #
+    def destination_root
+      @destination_stack.last
+    end
+
+    # Sets the root for this thor class. Relatives path are added to the
+    # directory where the script was invoked and expanded.
+    #
+    def destination_root=(root)
+      @destination_stack ||= []
+      @destination_stack[0] = File.expand_path(root || '')
+    end
+
+    # Returns the given path relative to the absolute root (ie, root where
+    # the script started).
+    #
+    def relative_to_original_destination_root(path, remove_dot=true)
+      path = path.gsub(@destination_stack[0], '.')
+      remove_dot ? (path[2..-1] || '') : path
+    end
+
+    # Holds source paths in instance so they can be manipulated.
+    #
+    def source_paths
+      @source_paths ||= self.class.source_paths_for_search
+    end
+
+    # Receives a file or directory and search for it in the source paths.
+    #
+    def find_in_source_paths(file)
+      relative_root = relative_to_original_destination_root(destination_root, false)
+
+      source_paths.each do |source|
+        source_file = File.expand_path(file, File.join(source, relative_root))
+        return source_file if File.exists?(source_file)
+      end
+
+      message = "Could not find #{file.inspect} in any of your source paths. "
+
+      unless self.class.source_root
+        message << "Please invoke #{self.class.name}.source_root(PATH) with the PATH containing your templates. "
+      end
+
+      if source_paths.empty?
+        message << "Currently you have no source paths."
+      else
+        message << "Your current source paths are: \n#{source_paths.join("\n")}"
+      end
+
+      raise Error, message
+    end
+
+    # Do something in the root or on a provided subfolder. If a relative path
+    # is given it's referenced from the current root. The full path 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.
+    # config<Hash>:: give :verbose => true to log and use padding.
+    #
+    def inside(dir='', config={}, &block)
+      verbose = config.fetch(:verbose, false)
+
+      say_status :inside, dir, verbose
+      shell.padding += 1 if verbose
+      @destination_stack.push File.expand_path(dir, destination_root)
+
+      FileUtils.mkdir_p(destination_root) unless File.exist?(destination_root)
+      FileUtils.cd(destination_root) { block.arity == 1 ? yield(destination_root) : yield }
+
+      @destination_stack.pop
+      shell.padding -= 1 if verbose
+    end
+
+    # Goes to the root and execute the given block.
+    #
+    def in_root
+      inside(@destination_stack.first) { yield }
+    end
+
+    # 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, config={})
+      verbose = config.fetch(:verbose, true)
+      path    = find_in_source_paths(path) unless path =~ /^http\:\/\//
+
+      say_status :apply, path, verbose
+      shell.padding += 1 if verbose
+
+      if URI(path).is_a?(URI::HTTP)
+        contents = open(path, "Accept" => "application/x-thor-template") {|io| io.read }
+      else
+        contents = open(path) {|io| io.read }
+      end
+
+      instance_eval(contents, path)
+      shell.padding -= 1 if verbose
+    end
+
+    # Executes a command returning the contents of the command.
+    #
+    # ==== Parameters
+    # command<String>:: the command to be executed.
+    # config<Hash>:: give :verbose => false to not log the status. Specify :with
+    #                to append an executable to command executation.
+    #
+    # ==== Example
+    #
+    #   inside('vendor') do
+    #     run('ln -s ~/edge rails')
+    #   end
+    #
+    def run(command, config={})
+      return unless behavior == :invoke
+
+      destination = relative_to_original_destination_root(destination_root, false)
+      desc = "#{command} from #{destination.inspect}"
+
+      if config[:with]
+        desc = "#{File.basename(config[:with].to_s)} #{desc}"
+        command = "#{config[:with]} #{command}"
+      end
+
+      say_status :run, desc, config.fetch(:verbose, true)
+      `#{command}` unless options[:pretend]
+    end
+
+    # Executes a ruby script (taking into account WIN32 platform quirks).
+    #
+    # ==== Parameters
+    # command<String>:: the command to be executed.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    def run_ruby_script(command, config={})
+      return unless behavior == :invoke
+      run command, config.merge(:with => Thor::Util.ruby_command)
+    end
+
+    # Run a thor command. A hash of options can be given and it's converted to
+    # switches.
+    #
+    # ==== Parameters
+    # task<String>:: the task to be invoked
+    # args<Array>:: arguments to the task
+    # config<Hash>:: give :verbose => false to not log the status. Other options
+    #                are given as parameter to Thor.
+    #
+    # ==== Examples
+    #
+    #   thor :install, "http://gist.github.com/103208"
+    #   #=> thor install http://gist.github.com/103208
+    #
+    #   thor :list, :all => true, :substring => 'rails'
+    #   #=> thor list --all --substring=rails
+    #
+    def thor(task, *args)
+      config  = args.last.is_a?(Hash) ? args.pop : {}
+      verbose = config.key?(:verbose) ? config.delete(:verbose) : true
+      pretend = config.key?(:pretend) ? config.delete(:pretend) : false
+
+      args.unshift task
+      args.push Thor::Options.to_switches(config)
+      command = args.join(' ').strip
+
+      run command, :with => :thor, :verbose => verbose, :pretend => pretend
+    end
+
+    protected
+
+      # Allow current root to be shared between invocations.
+      #
+      def _shared_configuration #:nodoc:
+        super.merge!(:destination_root => self.destination_root)
+      end
+
+      def _cleanup_options_and_set(options, key) #:nodoc:
+        case options
+          when Array
+            %w(--force -f --skip -s).each { |i| options.delete(i) }
+            options << "--#{key}"
+          when Hash
+            [:force, :skip, "force", "skip"].each { |i| options.delete(i) }
+            options.merge!(key => true)
+        end
+      end
+
+  end
+end

data/lib/core/traceable_factory.rb

@@ -0,0 +1,20 @@
+require 'core/traceable_object'
+
+class TraceableFactory
+
+  def self.createTraceableObject( className, *args )
+
+    TraceableObject.before_init(className) if Rcli.trace_app
+    
+    obj = Object.const_get( className ).new(*args)
+    
+    TraceableObject.after_init(className) if Rcli.trace_app
+
+    if Rcli.trace_app
+      return TraceableObject.new(obj,*args)
+    else
+      return obj
+    end
+  end
+    
+end

data/lib/core/traceable_object.rb

@@ -0,0 +1,45 @@
+class TraceableObject
+
+  def initialize(obj)
+    @obj = obj
+  end
+
+  def self.before_init(classname)
+    puts "-- s - #{classname}.initialize() ---"
+  end
+  
+  def self.after_init(classname)
+    puts "-- f - #{classname}.initialize() ---"
+    
+  end
+
+  def before_trace(sym)
+    puts "-- s - #{@obj.class}.#{sym}() ---"
+  end
+
+  def after_trace(sym)
+    puts "-- f - #{@obj.class}.#{sym}() ---"
+  end
+
+  def self.before_trace(className, sym)
+    puts "-- s - #{className}::#{sym}() ---"
+  end
+
+  def self.after_trace(className, sym)
+    puts "-- f - #{className}::#{sym}() ---"
+  end
+  
+  def method_missing(sym, *args, &block)
+    before_trace(sym)
+    @obj.send sym, *args, &block
+    after_trace(sym)
+  end
+
+  def self.call_class_method(className, sym, *args, &block)
+    self.before_trace(className, sym) if Rcli.trace_app
+    retval = Object.const_get( className ).send sym, *args, &block
+    self.after_trace(className, sym) if Rcli.trace_app
+    retval
+  end
+  
+end

data/lib/core/tracer.rb

@@ -0,0 +1,23 @@
+def s
+  trace = ''
+  m =  caller[0][/`([^']*)'/, 1] 
+  if "#{self.class}" == "Class"
+    trace = "-- s - #{self}::#{m}() --- "
+  else  
+    trace = "-- s - #{self.class}.#{m}() --- "
+  end
+  
+    puts trace if TRACE_APP
+end
+
+def f
+  trace = ''
+  m =  caller[0][/`([^']*)'/, 1] 
+  if "#{self.class}" == "Class"
+    trace = "-- f - #{self}::#{m}() --- "
+  else  
+    trace = "-- f - #{self.class}.#{m}() --- "
+  end
+  
+  puts trace if TRACE_APP
+end

data/lib/rcli.rb

@@ -0,0 +1,65 @@
+### Core Libraries
+require 'rubygems'
+require 'text'
+require 'YAML'
+require 'pp'
+require 'pathname'
+require 'highline/import'
+
+### Globals
+$verbose = false # set to true by command line
+DS = File::SEPARATOR # / on unix, \ on windows. DS is a shortcut and faster to type
+
+
+require 'core/shared/rcli_installation.rb'
+
+class Rcli
+
+  include Rcli::Installation
+
+  SRC_PATH = File.expand_path('~/lib/ruby/rcli_framework')
+  
+  GEM_ROOT = File.dirname(File.dirname(__FILE__))
+  GEM_LIB = GEM_ROOT + DS + 'lib'
+  GEM_BIN = GEM_ROOT + DS + 'bin'
+  GEM_CONFIG = GEM_ROOT + DS + 'lib' + DS + 'config'
+  
+  RCLI_DOTFOLDER = File.expand_path("~" + DS + '.rcli')
+  
+  if File.exists? (RCLI_DOTFOLDER + DS + 'config.yml')
+    RCLI_CONFIG = YAML.load_file(RCLI_DOTFOLDER + DS + 'config.yml')
+  else
+    RCLI_CONFIG = YAML.load_file(GEM_LIB + DS + 'config' + DS + 'application.yml')
+  end
+
+  @@trace_app = false
+  @@script_root = 'uninitialized'
+  @@script_config = nil
+  @@type = :app
+  
+  def self.script_root ; @@script_root ; end
+  def self.script_root=(sr) ; 
+    @@script_root = sr ; 
+    if @@type == :app
+      @@script_config = YAML.load_file(sr + DS + 'config' + DS + 'application.yml')
+    else
+      @@script_config = RCLI_CONFIG
+    end
+  end
+  def self.script_config ; @@script_config ; end
+  def self.script_config=(sc) ; @@script_config = sc ; end
+  def self.trace_app ; @@trace_app ; end
+  def self.trace_app=(ta) ; @@trace_app = ta ; end
+  def self.type ; @@type ; end
+  def self.type=(t) ; @@type = t ; end
+  
+  def self.go ; Commander.new.go ; end
+end
+
+
+### Application Libraries
+require 'core/traceable_factory'
+require 'core/actions'
+require 'core/global_functions'
+require 'vendor/trollop'
+require 'core/commander'

data/lib/templates/new_app/RCLIAPPNAME.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'rcli'
+
+#Rcli.trace_app = true # Uncomment if you want to enable tracing.
+
+### LAUNCH RCLIAPPNAME
+Rcli.script_root = Pathname(__FILE__).realpath.parent.to_s
+Commander.new.go

data/lib/templates/new_app/lib/commands/default.rb

@@ -0,0 +1,12 @@
+class DefaultCommand  < Command
+  
+  #description "Your application description (showed in help) goes here"
+  #usage "RCLIAPPNAME [-hv]"
+  
+  def main
+    # script code goes here:
+    
+  end
+
+
+end

data/lib/templates/new_app/lib/commands/version.rb

@@ -0,0 +1,6 @@
+class VersionCommand < Command
+  
+  def main
+    puts "RCLIAPPNAME -- version 0.1a"
+  end
+end