ro_commands 0.0.1

data/lib/ro_commands/refactor.rb

@@ -0,0 +1,78 @@
+module RoCommands
+  class Refactor < Base
+    desc 'rename', ''
+
+    def rename(from, to)
+      _rename(from, to)
+      _rename(from.camelize, to.camelize)
+    end
+
+    private
+
+    def _rename(from, to)
+      return if from == to
+      if from.is_a?(String) and to.is_a?(String)
+        fs =find('.')
+        fs.each do |f|
+          if test(?f, f)
+            sub_file(f, from, to)
+          else
+            sub_dir(f, from, to)
+          end
+        end
+      end
+    end
+
+    private
+
+    def sub_dir(f, from, to)
+      parent, basename = parent_basename(f)
+      sub_basename(parent, basename, from, to)
+    end
+
+    def sub_file(f, from, to)
+      parent, basename, ctn = parent_basename_ctn(f)
+      if basename.match from
+        basename = sub_basename(parent, basename, from, to)
+      end
+
+      begin
+        r = ctn[/\b#{from}\b/]
+      rescue => e
+        puts "Unknown content in #{f}"
+        puts e
+      end
+
+      if r
+        puts "substitute in #{basename}, from #{from} to #{to}"
+        new_ctn = ctn.gsub whole_match(from), ''
+        File.write File.join(parent, basename), new_ctn
+      end
+    end
+
+    def sub_basename(parent, basename, from, to)
+      new_name = basename.gsub(from, to)
+      puts "rename from #{basename} to #{new_name}"
+      FileUtils.mv(File.join(parent, basename), File.join(parent, new_name))
+      basename = new_name
+    end
+
+    def whole_match(from)
+      /\b#{from}\b/
+    end
+
+    private
+
+    def parent_basename_ctn(file)
+      parent, basename = parent_basename(file)
+      ctn = File.read file
+      return parent, basename, ctn
+    end
+
+    def parent_basename(file)
+      parent = File.dirname file
+      basename = File.basename file
+      return parent, basename
+    end
+  end
+end

data/lib/ro_commands/ro_helper.rb

@@ -0,0 +1,76 @@
+# gotchas: please use extend ::RoCommands::RoHelper, make sure module first extend 'method_added' method
+# example:
+#
+#module TryHelper
+#  extend ::RoCommands::RoHelper
+#  class << self
+#    def _template_in_self
+#
+#    end
+#  end
+#
+#  def _template_in_normal
+#
+#  end
+#end
+
+module RoCommands
+  module RoHelper
+
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+      end
+    end
+
+    module ClassMethods
+
+      def meth_feature
+        %r{^_}
+      end
+
+      def meths
+        @meths.uniq! if @meths.respond_to?(:uniq!)
+        @meths ||= []
+      end
+
+      def method_added(meth)
+        super
+        #puts "method:#{meth}"
+        def_meth(meth)
+      end
+
+
+      def singleton_method_added(meth)
+        super
+        #puts "singleton_method:#{meth}"
+        def_meth(meth, 'singleton')
+      end
+
+      def def_meth(meth, meth_type=nil)
+        meth = meth.to_s
+        if defined?(meth_feature) and meth.match(meth_feature)
+          if meth.match(%r{_})
+            new_method = meth.to_s.sub(%r{_}, "")
+
+            if meth_type == 'singleton'
+              define_singleton_method new_method.to_sym do |*args|
+                before_each if defined? before_each
+                send(meth.to_sym, *args)
+                after_each if defined? after_each
+              end
+            else
+              define_method new_method.to_sym do |*args|
+                before_each if defined? before_each
+                send(meth.to_sym, *args)
+                after_each if defined? after_each
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/lib/ro_commands/ro_procs.rb

@@ -0,0 +1,106 @@
+module RoCommands
+  class RoProcs < Base
+    attr_accessor :rps
+
+    desc 'grep_and_return_pids', ''
+
+    desc 'pids keywords', 'get pids with keywords'
+
+    def pids(*keywords)
+      rps_with keywords
+      pids = procs.map do |rp|
+        rp.instance_variable_get(:@pid)
+      end
+      create_table
+      puts pids
+      pids
+    end
+
+    desc 'grep', ''
+
+    def grep(*keywords)
+      rps_with(keywords)
+      create_table
+    end
+
+    private
+
+    class RoProc
+
+      def to_s
+        row = []
+        [:@user, :@pid, :@pmem, :@pcpu, :@command].each do |iv|
+          row << ("%-10s" % self.instance_variable_get(iv))
+        end
+        row.join
+      end
+
+    end
+
+
+    def create_table
+      r = %w(user pid pmem pcpu command).map do |heading|
+        "%-10s"%heading
+      end.join
+      puts r
+      puts procs.sort_by { |p| p.instance_variable_get "@#{sort}".to_sym }
+      puts r
+    end
+
+    def procs
+      @procs ||= []
+    end
+
+    def sort
+      @sort ||= "pcpu"
+    end
+
+    def rps_with(keywords)
+      parse
+      if keywords
+        keywords.each do |keyword|
+          search(keyword)
+        end
+      end
+    end
+
+
+    def search(keyword)
+      r = Regexp.new keyword
+      procs.each do |rp|
+        command= rp.instance_variable_get(:@command)
+
+        unless command[r]
+          procs - [rp]
+        end
+      end
+    end
+
+    def parse
+      attrs = %w(user pid pmem pcpu command)
+      ps ||= `ps -eo #{attrs.join(",")}`
+      _ps = ps.split("\n")
+      attr_names = _ps.shift.split(/\s+/)
+      _ps.each do |p|
+        rp = RoProc.new
+        p[/\/\w+/]
+        attr_values = p.scan(/[^\s]+/)
+        attr_names[0..3].each_with_index do |attr_name, index|
+          command = attr_values[index]
+          attr_name = attr_name.gsub(/%/, 'p').downcase
+          rp.instance_variable_set "@#{attr_name}".to_sym, attr_values[index]
+        end
+
+        command_value = get_command_value attr_values
+        rp.instance_variable_set :@command, command_value
+
+        procs << rp
+
+      end
+    end
+
+    def get_command_value(attr_values)
+      r = attr_values[4..-1].join(" ")
+    end
+  end
+end

data/lib/ro_commands/rubymine.rb

@@ -0,0 +1,17 @@
+module RoCommands
+  class Rubymine < Base
+    desc 'open', 'open one project'
+    def open(project_name = '.')
+      puts "opening #{project_name}"
+      bash "rubymine #{project_name}"
+    end
+
+    desc 'open_multi_projects', 'open multi projects'
+    def open_multi_projects(*project_names)
+      project_names.each do |name|
+        open(name)
+      end
+    end
+  end
+end
+

data/lib/ro_commands/shortcuts.rb

@@ -0,0 +1,67 @@
+module RoCommands
+  class Shortcuts < Base
+
+    desc usage("work"), ''
+
+    def work
+      action("zeus start")
+      bx "rake sunspot:solr:run"
+      bx "spork"
+      bx "guard"
+    end
+
+    private
+
+    def bx(cmd)
+      action "bundle exec #{cmd}"
+    end
+
+    def action(cmd, postpone=0.012)
+      a_action(cmd)
+      change_tab_name(cmd)
+      new_tab
+      sleep postpone
+    end
+
+    def a_action(name)
+      type name
+      enter
+    end
+
+    def change_tab_name(name)
+      key 'f2'
+      type name
+      enter
+    end
+
+    def enter
+      key 'KP_Enter'
+    end
+
+    def new_tab
+      bash 'xdotool key ctrl+t'
+    end
+
+    def key(name)
+      if name.match(%r{(f|F)\d{1,2}})
+        name.capitalize!
+      end
+      bash "xdotool key #{name}"
+    end
+
+    def translate(name)
+
+    end
+
+    def dict
+      {
+          enter: "KP_Enter"
+      }
+    end
+
+    def type(str)
+      bash "xdotool type '#{str}'"
+    end
+
+  end
+end

data/lib/ro_commands/try.rb

@@ -0,0 +1,11 @@
+require_relative "base"
+
+module RoCommands
+  class Try < Base
+    desc usage("try"), ""
+
+    def try_meth(*args)
+      Out.out "puts try_meth args:#{args.flatten}"
+    end
+  end
+end

data/lib/ro_commands/version.rb

@@ -0,0 +1,3 @@
+module RoroCommands
+  VERSION = "0.0.1"
+end

data/lib/ro_commands/zeus.rb

@@ -0,0 +1,18 @@
+require "find"
+require "fileutils"
+module RoCommands
+  class Zeus < Base
+    desc usage("init"), ""
+
+    def init
+      Find.find(File.expand_path("../zeus_templates", __FILE__)) do |f|
+        if test(?f, f)
+          to = File.basename f
+          puts "FileUtils.cp #{f}, #{to}"
+          FileUtils.cp f, to
+        end
+      end
+    end
+  end
+end
+

data/lib/ro_commands/zeus_templates/custom_plan.rb

@@ -0,0 +1,18 @@
+require 'zeus/rails'
+require "ro_commands/rails"
+
+class CustomPlan < Zeus::Rails
+
+  def rails
+    RoCommands::Rails.start
+  end
+  # def my_custom_command
+  #  # see https://github.com/burke/zeus/blob/master/docs/ruby/modifying.md
+  # end
+
+  def git_flow
+    RoCommands::GitFlow.start
+  end
+end
+
+Zeus.plan = CustomPlan.new

data/lib/ro_commands/zeus_templates/zeus.json

@@ -0,0 +1,24 @@
+{
+  "command": "ruby -rubygems -r./custom_plan -eZeus.go",
+
+  "plan": {
+    "boot": {
+      "default_bundle": {
+        "development_environment": {
+          "rails":["rails"],
+          "git_flow":["git_flow"],
+          "prerake": {"rake": []},
+          "console": ["c"],
+          "server": ["s"],
+          "generate": ["g"],
+          "destroy": ["d"],
+          "dbconsole": []
+        },
+        "test_environment": {
+          "cucumber_environment": {"cucumber": []},
+          "test_helper": {"test": ["rspec", "testrb"]}
+        }
+      }
+    }
+  }
+}

data/lib/ro_helper.rb

@@ -0,0 +1,25 @@
+module RoHelper
+  class Cmd
+    attr_accessor :shortcut, :cmd, :suggestion
+
+    def initialize(shortcut, cmd, suggestion=nil)
+      @shortcut = shortcut
+      @cmd = cmd
+      @suggestion = suggestion
+    end
+  end
+
+  def cmd(*args)
+    cmds << Cmd.new(*args)
+  end
+
+  def cmds
+    @cmds.flatten! if @cmds.respond_to?(:flatten!)
+    @cmds.uniq! if @cmds.respond_to?(:uniq!)
+    @cmds ||= []
+  end
+
+  def cmd_objs
+
+  end
+end