ro_commands 0.0.1

data/lib/ro_commands/helpers/all.rb

@@ -0,0 +1,8 @@
+require_relative "all_files"
+require "ro_commands/base"
+
+RoCommands::file_map.each do |file, _|
+  require file.to_s
+end
+
+

data/lib/ro_commands/helpers/all_files.rb

@@ -0,0 +1,21 @@
+require "ro_commands/core_ext/string"
+
+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
+  end
+
+  files = Dir[File.join($lib, "ro_commands/**")].select do |f|
+    test(?f, f)
+  end.delete_if do |f|
+    f = File.basename(f)
+    f.match(%r{all|version|ro_helper|hook|out})
+  end
+  files.each_with_index do |file, i|
+    file_map[file.to_sym] = 8000 + i
+  end
+end

data/lib/ro_commands/helpers/bash.rb

@@ -0,0 +1,33 @@
+require_relative "out"
+module Bash
+  def _bash(cmd)
+    cmd = handle_path(cmd)
+    result = `#{cmd}`
+    Out.out result
+  end
+
+  def handle_path(cmd)
+    r = cmd[/\/(\w|\/)*/]
+    if r
+      cmd.gsub! r, "\'#{r}\'"
+    else
+      cmd
+    end
+  end
+
+  def bash(*cmds)
+    unless cmds.empty?
+      _bash(cmds.flatten.join(" && "))
+    end
+  end
+
+  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/helpers/out.rb

@@ -0,0 +1,29 @@
+class Out
+  class << self
+    def out(msg)
+      m = msg
+      puts m
+      msgs << m
+    end
+
+    def reset
+      @msgs = []
+    end
+
+    def msgs
+      @msgs.flatten! if @msgs.respond_to?(:flatten!)
+      @msgs = [] if @msgs and @msgs.length > 999
+      @msgs ||= []
+    end
+
+    #class Msg
+    #  def initialize(msg)
+    #    @msg = msg
+    #  end
+    #
+    #  def to_s
+    #    @msg
+    #  end
+    #end
+  end
+end

data/lib/ro_commands/hook.rb

@@ -0,0 +1,102 @@
+require "method_source"
+module RoCommands
+  module Hook
+    class << self
+      def method_added(meth)
+        meths << meth
+        super
+      end
+
+      def meths
+        @meths ||= []
+      end
+    end
+
+    def included?(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def target
+        File.expand_path("../ro_commands", __FILE__)
+      end
+
+      def get_meth_blk(method)
+        r = self.method(method).source.split("\n")
+        meth_blk = Proc.new do
+          meth_ctn = (r - [r[0], r[-1]]).join("\n")
+          eval meth_ctn
+        end
+      end
+
+      def ctn
+        @ctn ||= ""
+      end
+
+      def after_each
+        content << ctn
+      end
+
+      def content
+        @content ||= []
+      end
+
+    end
+  end
+end
+
+#class BashBuilder
+#  extend BashBuilderHelper::ClassMethods
+#
+#  class << self
+#    def is_helper?(meth)
+#      BashBuilderHelper.meths.include?(meth)
+#    end
+#
+#    def defined_meths
+#      @defined_meths ||= []
+#    end
+#
+#    def singleton_method_added(method)
+#      unless method.to_s.match "singleton_method_added" or defined_meths.include?(method)
+#        defined_meths << method
+#        defined_meths.uniq!
+#        if self.respond_to?(:get_meth_blk)
+#          meth_blk = get_meth_blk(method)
+#          unless is_helper?(method)
+#            define_singleton_method method do |*args|
+#              meth_blk.call
+#              after_each
+#            end
+#          end
+#        end
+#      end
+#    end
+#
+#    def set(shortcut, full, desc)
+#      ctn = <<-CONTENT
+#      CONTENT
+#    end
+#
+#    def build
+#      dir = File.expand_path("../bash_templates", __FILE__)
+#      Dir[File.join(dir, '**')].each do |file|
+#        template(file)
+#      end
+#      write_into_bash_file
+#    end
+#
+#    def template(name)
+#      path = File.expand_path("../bash_templates/#{name}", __FILE__)
+#      ctn = ERB.new(File.read(path)).result(binding)
+#    end
+#
+#    def build_paths
+#      template("paths")
+#    end
+#
+#    def write_into_bash_file
+#      File.write(target(), content)
+#    end
+#  end
+#end

data/lib/ro_commands/info.rb

@@ -0,0 +1,55 @@
+require_relative "dsl/file"
+module RoCommands
+  class Info < Base
+    include DSL::File
+
+    class RoFile
+      def initialize(path, size)
+        @path = path
+        @size = size
+      end
+
+      def path
+      	@path ||= nil
+      end
+
+      def size
+      	@size ||= nil
+      end
+
+      def to_s
+        "size:#{size}, path:#{path}"
+      end
+    end
+
+    desc 'file_size', ''
+
+    def file_size(path, recursive=false)
+      if recursive
+        find(path).each do |f|
+          files << RoFile.new(f, size(f))
+        end
+        puts files.sort_by(&:size)
+      else
+        Dir[File.join(path, "**")].each do |f|
+          if dir?(f)
+            s = find(f).inject(0) { |total_size, file_size| total_size += size(f) }
+            rf = RoFile.new(f, s)
+          else
+            rf = RoFile.new(f, size(f))
+          end
+          files << rf
+        end
+
+        puts files.sort_by(&:size)
+      end
+    end
+
+
+    private
+
+    def files
+      @files ||= []
+    end
+  end
+end

data/lib/ro_commands/misc.rb

@@ -0,0 +1,77 @@
+require "find"
+require "fileutils"
+module RoCommands
+  class Misc < Base
+
+    desc 'rt', 'root find'
+
+    def root_find(keyword)
+      bash "find / -iname '*#{keyword}*'"
+    end
+
+    desc 'rc', 'railscasts find'
+
+    def railscasts_find(keyword)
+
+      bash "find /media/zxr/New-Volume/TDDOWNLOAD/railscasts/ -iname '*#{keyword}*'"
+    end
+
+    desc 'move_zip_to', 'move zip to another dir'
+
+    def move_zip_to(target_dir, keyword=".*", src='.')
+      filter = %r{#{keyword}}
+      Find.find(src) do |file|
+        if is_zip?(file) or is_rar?(file) and file.match filter
+          FileUtils.mv file, target_dir
+        end
+
+        unzip_r(target_dir)
+      end
+    end
+
+    desc 'unzip_r', 'unzip all file twice'
+
+    def unzip_r(dir=".")
+      Dir.chdir dir
+      Find.find(Dir.pwd) do |file|
+        if test(?f, file)
+          try_zip(file)
+        end
+      end
+    end
+
+    private
+
+    def old_dir
+      @old_dir ||= ''
+    end
+
+    def try_zip(file)
+      if is_zip?(file)
+        create_uncompressed_dir(file) do
+          bash "unzip -n #{file} -d #{dir}"
+        end
+
+      elsif  is_rar?(file)
+        create_uncompressed_dir(file) do |dir|
+          bash "unrar x -o- #{file} #{dir}"
+        end
+      end
+    end
+
+    def is_rar?(file)
+      bash("unrar l #{file}")
+    end
+
+    def is_zip?(file)
+      bash("unzip -l #{file}")
+    end
+
+    def create_uncompressed_dir(zip_file)
+      dir = "#{File.basename zip_file}_inner"
+      FileUtils.mkpath dir
+      yield dir
+    end
+  end
+end
+

data/lib/ro_commands/navigate.rb

@@ -0,0 +1,56 @@
+require "ro_commands/helpers/out"
+module RoCommands
+  class Navigate < Base
+
+    desc "get_dir", ""
+
+    def get_dir(name)
+      Find.find(File.join(ENV['HOME'], 'Dropbox')) do |f|
+        if test(?d, f)
+          if File.basename(f).match /^#{name}/
+            puts f
+            return
+          end
+        end
+      end
+    end
+
+
+    desc 'get_project', 'get project path according name'
+
+    def get_project(name, lan='ruby')
+
+      if lan == 'ruby'
+        projects = Dir[File.join ENV['PROJECTS'], '**']
+      elsif lan == 'java'
+        projects = Dir[File.join ENV['JAVA'], '**']
+      end
+
+      projects.each do |path|
+        dir = File.basename path
+        if dir == name
+          Out.reset
+          Out.out(path)
+          return
+        end
+      end
+
+      r = /^#{name.split('').join(".*")}.*/i
+      projects.each do |path|
+        dir = File.basename path
+        if dir[r]
+          Out.reset
+          Out.out(path)
+          return
+        end
+      end
+    end
+
+    private
+
+    def handle_drb_out
+      #Out.out "result:#{result}   file:#{File.basename __FILE__} line:#{__LINE__}"
+      Out.msgs.grep(%r{/\w+}).first
+    end
+  end
+end

data/lib/ro_commands/processes.rb

@@ -0,0 +1,12 @@
+module RoCommands
+  class Processes < Base
+    desc 'kill KEYWORD', 'kill process with keyword'
+    def kill(keyword)
+      `ps aux | grep #{keyword}`.split("\n").each do |process|
+        puts process
+        pid = process.scan(/\d+/).first
+        bash "kill #{pid}"
+      end
+    end
+  end
+end

data/lib/ro_commands/rails.rb

@@ -0,0 +1,210 @@
+require_relative "base"
+require_relative "git"
+require_relative "ro_helper"
+
+module RoCommands
+  class Rails < Base
+
+    class << self
+      def method_added(method)
+        super
+        unless method.match(%r{})
+          meths << method
+        end
+        meths.uniq!
+      end
+
+      def meths
+        @meths ||= []
+      end
+
+      def generators_map
+        @generators_map ||= {
+            scaffold: 's',
+            migration: 'm',
+            model: 'mo',
+            controller: 'c',
+            assets: 'a',
+            task: 't'
+        }
+      end
+
+      def set_shortcut_method(item)
+        class_eval do
+          #shortcut_item = generators_map[item.to_sym]
+          #desc usage(shortcut_item), describe('generate', item, shortcut_item)
+          #
+          #define_method shortcut_item.to_sym do |*args|
+          #  send item.to_sym, *args
+          #end
+
+          #shortcut_item_d = "#{shortcut_item}_d"
+          #item_d = "#{item}_d"
+          #
+          #desc usage(shortcut_item_d), describe('destroy', item, shortcut_item_d)
+          #define_method shortcut_item_d.to_sym do |*args|
+          #  send item_d.to_sym, *args
+          #end
+        end
+      end
+
+
+      def items
+        @items ||= %w(migration scaffold model)
+      end
+
+      def items2
+        @items2 ||= %w(controller task assets)
+      end
+    end
+
+
+    items.each do |i|
+      self.class_eval do
+
+        desc usage(i), describe('generate', i, generators_map[i.to_sym])
+        define_method i do |*args|
+          item_g(i, args)
+        end
+
+        #desc usage("#{i}_d"), describe('destroy', i, generators_map[i.to_sym])
+        #define_method "#{i}_d" do |name|
+        #  item_d(i, name)
+        #end
+        set_shortcut_method i
+      end
+    end
+
+
+    #items2.each do |i|
+    #
+    #  self.class_eval do
+    #    desc usage(i), describe("generate", i, generators_map[i.to_sym])
+    #    define_method i do |*args|
+    #      item_g(i, args)
+    #    end
+    #
+    #    i_d = "#{i}_d"
+    #    desc usage(i_d), describe("destroy", i, generators_map[i.to_sym])
+    #    define_method i_d do |name|
+    #      item_d(i, name)
+    #    end
+    #
+    #    set_shortcut_method i
+    #  end
+    #end
+    desc usage("scaffolds"), ""
+
+    def scaffolds
+      get_controllers
+    end
+
+    desc usage("get_migrations"), ''
+
+    def get_migrations
+      Find.find('db/migrate').select do |f|
+        f.match(%r{rb$})
+      end.map do |f|
+        File.basename(f).gsub(%r(^\d+_), "")
+      end
+    end
+
+    desc usage("get_models"), ''
+
+    def get_models
+      get_rails_files('models')
+    end
+
+    desc usage("get_assets"), ''
+
+    def get_assets
+      get_files('assets') do |f|
+        f.match(%r{(js|coffee|scss|css)$})
+      end
+    end
+
+    desc usage("get_controllers"), ''
+
+    def get_controllers
+      get_rails_files('controllers')
+    end
+
+
+    private
+
+    def scaffold_g_for_spec(*args)
+      item_g "scaffold_for_spec", args
+    end
+
+    def scaffold_d_for_spec(name)
+      item_d "scaffold_for_spec", name
+    end
+
+    def item_d(item, name)
+      bash "zeus d #{item} #{name}"
+    end
+
+    def item_g(item, args)
+      cmd = args_parse(args.flatten, sql_type_dict)
+      bash "zeus g #{item} #{cmd}"
+      cmd
+    end
+
+    def args_parse(args, dict)
+      name = args.shift
+      options = get_options args.flatten
+      options = convert options, dict
+
+      cmd = name
+      options.each do |attr, type|
+        cmd = "#{cmd} #{attr}:#{type}"
+      end
+      cmd
+    end
+
+    def convert(options, dict)
+      parse_options(options, dict)
+    end
+
+    def sql_type_dict
+      {
+          i: "integer",
+          f: "float",
+          d: "double",
+          s: "string",
+          t: "text",
+          time: "time"
+      }
+    end
+
+    def app
+      @app.uniq! if @app.respond_to?(:uniq!)
+      @app ||= File.join(Dir.pwd, 'app')
+    end
+
+    def get_rails_files(dir)
+      get_files(dir) do |f|
+        f.match(%r{rb$})
+      end
+    end
+
+    def get_files(dir, &blk)
+      d = File.join(app, dir)
+      if test(?d, d)
+        files = Find.find(d).select &blk
+        files = files.map do |f|
+          File.basename(f).gsub(%r{\.(\w|\.)+$}, "")
+        end
+        puts files
+        files
+      end
+    end
+
+    def db
+      @db.uniq! if @db.respond_to?(:uniq!)
+      @db ||= File.join(Dir.pwd, 'db')
+    end
+
+  end
+end
+