ro_commands 0.0.3 → 0.0.4

data/lib/ro_core_ext/object.rb

@@ -0,0 +1,11 @@
+class Object
+  def have_value?
+    result = nil
+    if self.respond_to?(:blank?)
+      result = !self.blank?
+    elsif self.respond_to?(:empty?)
+      result = !self.empty?
+    end
+    result
+  end
+end

data/lib/ro_core_ext/pry.rb

@@ -0,0 +1,10 @@
+require 'pry'
+::Pry::CommandSet.class_eval do
+  def pry_cmd(name, desc='', &blk)
+    block_command name, desc do |*args|
+      ::Guard.pause
+      blk.call
+      ::Guard.pause
+    end
+  end
+end

data/lib/ro_core_ext/string.rb

@@ -0,0 +1,37 @@
+require 'term/ansicolor'
+
+String.class_eval do
+  include ::Term::ANSIColor
+
+  def shift
+    first_char = self[0]
+    self.gsub!(first_char, '')
+    first_char
+  end
+
+  unless defined? ::Rails
+    def camelize
+      r = self.split(/\W|_/).map do |e|
+        e[0] = e[0].upcase
+        e
+      end
+
+      r.join
+    end
+  end
+
+  def uncamelize
+    self.split(/(?=[A-Z])/).join("_").downcase
+  end
+
+  def implicit
+    self.split("").join(".*")
+  end
+
+  def pop(regexp)
+    result = self.match(regexp)[0]
+    self.gsub!(regexp, "")
+    result
+  end
+end
+

data/lib/ro_default.rb

@@ -0,0 +1,8 @@
+module RoDefault
+  class << self
+    attr_accessor :editor
+    def editor
+    	@editor ||= "rubymine"
+    end
+  end
+end

data/lib/ro_file.rb

@@ -0,0 +1,71 @@
+require File.expand_path('../../config/rorc', __FILE__)
+
+require 'fileutils'
+require 'ro_file'
+require 'ro_helpers/out'
+
+module RoFile
+  class << self
+    def read(file)
+      action_out("read", file)
+      File.read(file)
+    end
+
+    def change_recently?(file, internal=10)
+
+      Time.now - Time.at(test(?M, file)) < internal
+    end
+
+    def readlines(file)
+      action_out("readlines", file)
+      File.readlines(file)
+    end
+
+    def write(file, ctn)
+      action_out("write", file)
+      FileUtils.mkpath(File.dirname file)
+      File.write(file, ctn)
+    end
+
+    def remove_file(file)
+      if test(?f, file)
+        action_out('remove_file', file)
+        FileUtils.rm_f(file)
+      else
+        raise "#{file} is not a file"
+      end
+    end
+
+    def action_out(action, file)
+      Out.table "#{action}", "#{File.basename(file)}", "file:#{File.basename __FILE__} line:#{__LINE__}"
+    end
+
+    def template(file, tt, caller, caller_file)
+      if RoCommands.lib
+        template_path = File.join(RoCommands.lib, 'tt', "#{tt}.erb")
+      else
+        template_path = "#{tt}.erb"
+      end
+
+      ctn = File.read(template_path)
+      result = ERB.new(ctn).result(caller.send(:binding))
+      write(file, result)
+    end
+
+    def basename_ext(file)
+      basename, ext = nil
+      f = File.basename(file)
+
+      f.match(%r{(\w+)(\.\w+)?$}) do |m|
+        basename = File.basename $~[1]
+        ext = $~[2]
+      end
+      return [basename, ext].compact
+    end
+
+    #def puts(file, ctn)
+    #  action("puts", file)
+    #  File.send(:puts, file, result)
+    #end
+  end
+end

data/lib/ro_helpers.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../config/rorc', __FILE__)
+
+require_relative "deps"
+basename = File.basename(__FILE__).gsub(%r{\.\w+$}, "")
+Deps.require_all(basename)

data/lib/ro_helpers/all_ro_commands.rb

@@ -0,0 +1,4 @@
+require_relative "all_ro_commands_files"
+require "ro_commands/base"
+
+

data/lib/ro_helpers/all_ro_commands_files.rb

@@ -0,0 +1,42 @@
+require "ro_core_ext/string"
+require_relative 'ro_bin_helper'
+
+module RoCommands
+  class << self
+    def file_map
+      @meth_map.flatten! if @meth_map.respond_to?(:flatten!)
+      @meth_map.uniq! if @meth_map.respond_to?(:uniq!)
+      @meth_map ||= {}
+    end
+
+    def set_file_map(project_root, port_prefix)
+      files = get_files(project_root)
+      unless files.empty?
+        set_port(files, port_prefix)
+      end
+    end
+
+    def get_files(project_root)
+      ro_commands_dir = Dir[File.join(project_root, "lib/ro_commands/**")]
+
+      if ro_commands_dir.empty?
+        Out.warn("can't find ro_commands dir in #{project_root}", "file:#{File.basename __FILE__} line:#{__LINE__}")
+        []
+      else
+        files = ro_commands_dir.select do |f|
+          test(?f, f) and f.match(%r{(.+)\.rb$})
+        end.delete_if do |f|
+          f = File.basename(f)
+          f.match(%r{(all|version|ro_helper|hook|out)\.rb$})
+        end
+      end
+    end
+
+    def set_port(files, port_prefix)
+      files.each_with_index do |file, i|
+        file_map[file.to_sym] = "#{port_prefix}00".to_i + i
+      end
+    end
+  end
+end
+

data/lib/ro_helpers/bash.rb

@@ -0,0 +1,100 @@
+require_relative "out"
+require "open3"
+module Bash
+  class << self
+    def status
+      @@status ||= ''
+    end
+
+    def out
+      @@out ||= ''
+    end
+
+    def err
+      @@err ||= ''
+    end
+  end
+
+  def status
+    @@status ||= ""
+  end
+
+  def out
+    @@out ||= ""
+  end
+
+  def err
+    @@err ||= ""
+  end
+
+  def _bash(cmd)
+    cmd = handle_path(cmd)
+    Out.table("Running:", "#{cmd}")
+    @@out, @@err, @@status = Open3.capture3(cmd)
+    Out.out add_time(err)
+    Out.out add_time(out)
+    @@out
+  end
+
+  def add_time(str)
+    unless str.empty?
+      "#{Time.now.strftime("%H:%M:%S")}: #{str}"
+    end
+  end
+
+  # bash capture cmds result
+  def bash_capture(*cmds)
+    bash(*cmds)
+  end
+
+  alias_method :bashc, :bash_capture
+
+  def bash_capture_array(*cmds)
+    bash_capture(*cmds).split("\n")
+  end
+
+  alias_method :basha, :bash_capture_array
+
+  def handle_path(cmd)
+    path = %r{\w*/(\w|/|-)+}
+    r = cmd.gsub(path) do |m|
+      "\'#{m}\'"
+    end
+  end
+
+  def bash(*cmds)
+    unless cmds.empty?
+      _bash(cmds.flatten.join(" && "))
+    end
+  end
+
+  def bash_system(*cmds)
+    unless cmds.empty?
+      kernel_system(cmds.flatten.join(" && "))
+    end
+  end
+
+  def kernel_system(cmd)
+    Out.table "Running", "#{cmd}", "file:#{::File.basename __FILE__} line:#{__LINE__}"
+    Kernel.system cmd
+  end
+
+  alias_method :bashs, :bash_system
+  alias_method :guard_bash, :bash_system
+
+  def bundle_exec(cmd)
+    kernel_system("bundle exec #{cmd}")
+  end
+
+  alias_method :bx, :bundle_exec
+
+  def bash_per(*cmds)
+    cmds.each do |c|
+      bash c
+    end
+  end
+
+  def bash_lines(cmd)
+    bash(cmd).split("\n")
+  end
+end

data/lib/{ro_commands → ro_helpers}/hook.rb

@@ -1,5 +1,5 @@
 require "method_source"
-module RoCommands
+module RoHelpers
   module Hook
     class << self
       def method_added(meth)

data/lib/ro_helpers/out.rb

@@ -0,0 +1,154 @@
+require "fileutils"
+require 'thor'
+require "term/ansicolor"
+class Out
+  class << self
+    include ::Thor::Shell
+    include Term::ANSIColor
+    attr_accessor :msg
+
+    #%w(say say_status).each do |m|
+    #  define_method(:"#{m}") do |*args|
+    #    shell.send(:"#{m}", *args)
+    #  end
+    #end
+    def warn(msg, other=nil)
+      table("WARNING", msg, other, "red")
+    end
+
+    def table(status, msg, other=nil, color=nil)
+
+      status = status.ljust(7)
+      new_msg = msg.ljust(20)
+      say_with_color(status, new_msg, other, color)
+    end
+
+    def say_with_color(status, new_msg, other, color=nil)
+      color ||= "green"
+      say "#{time_now}#{send(:"#{color}", bold(status))}  #{new_msg} #{other}"
+    end
+
+    attr_accessor :output
+
+    def output
+      @output ||= STDOUT
+    end
+
+    def time_now
+      Time.now.strftime("%H:%M:%S - ")
+    end
+
+    def time_say(*args)
+      say([time.now, args])
+    end
+
+    def say(*args)
+      output.puts "#{args.flatten.join(" ")}"
+      output.flush
+    end
+
+    def debug(msg, color=nil)
+      if $RODEBUG
+        out(msg, color)
+      end
+    end
+
+    def out(msg, color=nil)
+      reset
+      if color
+        say send(:"#{color}", bold(msg))
+      else
+        say msg
+      end
+      @msg = handle_msg(msg)
+    end
+
+    def handle_msg(msg)
+      if msg.is_a?(Array)
+        msg.join("\n")
+      else
+        msg
+      end
+    end
+
+    def raw_out(msg, color=nil)
+      reset
+      if color
+        p send(color.to_sym, msg)
+      else
+        p msg
+      end
+      #write_tmp(m)
+      @msg = msg
+    end
+
+
+    def write_tmp(ctn)
+      if save?
+        unless ctn.match(%r{^\s*$})
+          tmp_ctn = tmp
+          tmp_ctn << "At #{Time.now}"
+          tmp_ctn << ctn
+          File.write(tmp_path, tmp_ctn.join("\n"))
+        end
+      else
+        if test(?s, tmp_path) and test(?s, tmp_path) > 10_000
+          FileUtils.rm_f(tmp_path)
+        end
+      end
+    end
+
+    def save?
+      @save
+    end
+
+    def save_on
+      File.write(tmp_path, "save_on at #{Time.now}")
+      @save = true
+    end
+
+    def save_off
+      File.write(tmp_path, "save_on at #{Time.now}")
+
+      @save = false
+    end
+
+    def save
+      @save ||= false
+    end
+
+    def tmp_path
+      FileUtils.touch "/tmp/ro_out"
+      @tmp_path ||= "/tmp/ro_out"
+    end
+
+    def tmp
+      if test(?f, tmp_path)
+        File.readlines(tmp_path).delete_if do |l|
+          l.blank?
+        end
+      else
+        FileUtils.touch tmp_path
+        []
+      end
+    end
+
+    def reset
+      @msg = ''
+    end
+
+    def msg
+      @msg ||= ''
+    end
+
+    #class Msg
+    #  def initialize(msg)
+    #    @msg = msg
+    #  end
+    #
+    #  def to_s
+    #    @msg
+    #  end
+    #end
+  end
+end