clone 1.0.0.alpha → 1.0.0.beta

data/lib/clone/generator/terminal.rb

@@ -0,0 +1,104 @@
+#encoding: UTF-8
+module Clone
+
+  ##require File.join "rubygems"
+  require File.join "commander", "import"
+
+  begin
+    ### Program runtime parameters
+    program :name, "#{self.to_s.split('::')[0].downcase}"
+    program :version, VERSION.show
+    program :description, "#{self.to_s.split('::')[0].downcase} commandline control"
+
+    #command :set do |c|
+    #  c.syntax = "#{self.to_s.split("::")[0].downcase} set --option value"
+    #  c.description = "help configure the generator params"
+    #  c.option "--structured true/false" , String , "set, that does generating follow the samples folder structure or not"
+    #  c.action do |args, options|
+    #
+    #    if !options.structured.nil?
+    #      if    options.structured == "true"
+    #        SampleConfig.yml_data['structured']= true
+    #        Yaml.set SampleConfig.yml_data
+    #      elsif options.structured == "false"
+    #        SampleConfig.yml_data['structured']= false
+    #        Yaml.set SampleConfig.yml_data
+    #      else
+    #        puts "undefined value for structured option:\n\tuse 'true' or 'false'"
+    #      end
+    #    end
+    #
+    #  end
+    #end
+
+    [:build,:generate].each do |one_sym|
+
+      command one_sym.to_sym do |c|
+        
+        if one_sym == :build
+          c.syntax = "gen generate cat cmd name str or --cat name --cmd name --name file_name --str true/false"
+          c.description= "help Generate samples from the sample collection\n\t"+
+              "categories:\n\t\t#{show_categories.gsub(':','')}"+
+              "\n\tcommands:\n\t\t#{show_commands.gsub(':','')}"+
+              "\n\tDescriptions:\n\n\t\t#{show_readmes}"
+        else
+          c.syntax=      "same for build command"
+          c.description= "alias for build command"
+        end
+
+        c.option "--name file_name"         , String , "choose file name, this is optionable, not required"
+        c.option "--cat category_name"      , String , "choose the category"
+        c.option "--cmd command_name"       , String , "choose the command"
+        c.option "--str true/false"         , String , "choose to either you want or not keep sample "+
+            "structure or generate everything in place"
+
+        c.option "--debug"
+        c.action do |args, options|
+
+          if options.debug
+            $DEBUG = true
+          end
+
+          ### Get options or else args
+          begin
+            if (options.cat).nil?
+              category = args[0]
+            else
+              category = options.cat
+            end
+            if (options.cmd).nil?
+              command = args[1]
+            else
+              command = options.cmd
+            end
+            if (options.name).nil?
+              file_name = args[2]
+            else
+              file_name = options.name
+            end
+            if (options.str).nil?
+              structured = args[3]
+            else
+              structured = options.str
+            end
+          end
+
+          ### Do the job
+          begin
+            command_for_sample_generate :category   => category,
+                                        :command    => command,
+                                        :structured => structured,
+                                        :file_name  => file_name
+          end
+
+
+
+        end
+      end
+
+
+    end
+
+  end
+
+end

data/lib/clone/helpers/helper_methods.rb

@@ -0,0 +1,251 @@
+### Helper methods
+module Clone
+
+  ### ClassMethods
+   begin
+    class << self
+
+      #Based on the rb location
+      def load_directory(directory,*args)
+        arg = Hash[*args]
+
+        #directory = File.expand_path(directory)
+        delayed_loads = Array.new
+
+        if !arg[:delayed].nil?
+          raise ArgumentError, "Delayed items must be in an "+\
+            "Array! Example:\n:delayed => ['abc']" if arg[:delayed].class != Array
+        end
+
+        if !arg[:excluded].nil?
+          raise ArgumentError, "Exclude items must be in an "+\
+            "Array! Example:\n:exclude => ['abc']" if arg[:excluded].class != Array
+        end
+
+        arg[:type]         ||= "rb"
+        arg[:monkey_patch] ||= 0
+        #=============================================================================================================
+
+        ### GET Pre path + validation
+        begin
+          #get method callers path
+
+          pre_path = caller[arg[:monkey_patch].to_i].split('.rb:').first+('.rb')
+
+          if !pre_path.include?('/') && !pre_path.include?('\\')
+            pre_path = File.expand_path(pre_path)
+          end
+
+          separator_symbol= String.new
+          pre_path.include?('/') ? separator_symbol = '/' : separator_symbol = '\\'
+
+          pre_path= ((pre_path.split(separator_symbol))-([pre_path.split(separator_symbol).pop])).join(separator_symbol)
+
+        end
+
+        puts "prepath: "+pre_path.inspect if $DEBUG
+
+        puts "LOADING_FILES_FROM_"+directory.to_s.split(separator_symbol).last.split('.').first.capitalize if $DEBUG
+
+        puts "Elements found in #{directory}"                                                 if $DEBUG
+        puts File.join("#{pre_path}","#{directory}","**","*.#{arg[:type]}")                   if $DEBUG
+        puts Dir[File.join("#{pre_path}","#{directory}","**","*.#{arg[:type]}")].sort.inspect if $DEBUG
+
+        Dir[File.join("#{pre_path}","#{directory}","**","*.#{arg[:type]}")].sort.each do |file|
+
+          arg[:delayed]=  [nil] if arg[:delayed].nil?
+          arg[:excluded]= [nil] if arg[:excluded].nil?
+
+          arg[:excluded].each do |except|
+            if file.split(separator_symbol).last.split('.').first == except.to_s.split('.').first
+
+              puts file.to_s + " cant be loaded because it's an exception" if $DEBUG
+
+            else
+
+              arg[:delayed].each do |delay|
+
+                if file.split(separator_symbol).last.split('.').first == delay.to_s.split('.').first
+                  delayed_loads.push(file)
+                else
+                  load(file)
+                  puts file.to_s if $DEBUG
+                end
+
+              end
+
+            end
+          end
+        end
+        delayed_loads.each do |delayed_load_element|
+          load(delayed_load_element)
+          puts delayed_load_element.to_s    if $DEBUG
+        end
+        puts "DONE_LOAD_FILES_FROM_"+directory.to_s.split(separator_symbol).last.split('.').first.capitalize if $DEBUG
+
+      end
+
+      def error_logger(error_msg,prefix="",log_file=App.log_path)
+
+        ###convert error msg to more human friendly one
+        begin
+          error_msg= error_msg.to_s.gsub('", "','",'+"\n\"")
+        rescue Exception
+          error_msg= error_msg.inspect.gsub('", "','",'+"\n\"")
+        end
+
+        if File.exists?(File.expand_path(log_file))
+          error_log = File.open( File.expand_path(log_file), "a+")
+          error_log << "\n#{Time.now} | #{prefix}#{":" if prefix != ""} #{error_msg}"
+          error_log.close
+        else
+          File.new(File.expand_path(log_file), "w").write(
+              "#{Time.now} | #{prefix}#{":" if prefix != ""} #{error_msg}"
+          )
+        end
+
+        return {:error => error_msg}
+      end
+
+      def load_ymls(directory,*args)
+        arg= Hash[*args]
+
+        require 'yaml'
+        #require "hashie"
+
+        arg[:monkey_patch]= 0 if arg[:monkey_patch].nil?
+
+
+        ### GET Pre path + validation
+        begin
+          #get method callers path
+          pre_path = caller[arg[:monkey_patch].to_i].split('.rb:').first+('.rb')
+          if !pre_path.include?('/') && !pre_path.include?('\\')
+            pre_path = File.expand_path(pre_path)
+          end
+          separator_symbol= String.new
+          pre_path.include?('/') ? separator_symbol = '/' : separator_symbol = '\\'
+          pre_path= ((pre_path.split(separator_symbol))-([pre_path.split(separator_symbol).pop])).join(separator_symbol)
+        end
+
+        puts "Elements found in #{directory}"                                       if $DEBUG
+        puts File.join("#{pre_path}","#{directory}","**","*.yml")                   if $DEBUG
+        puts Dir[File.join("#{pre_path}","#{directory}","**","*.yml")].sort.inspect if $DEBUG
+
+        yaml_files = Dir[File.join("#{pre_path}","#{directory}","**","*.yml")].sort
+
+        puts "\nyaml file found: "+yaml_files.inspect                               if $DEBUG
+
+        @result_hash = {}
+        yaml_files.each_with_index do |full_path_file_name|
+
+
+          file_name = full_path_file_name.split(separator_symbol).last.split(separator_symbol).first
+
+          hash_key = file_name
+          @result_hash[hash_key] = YAML.load(File.read("#{full_path_file_name}"))
+
+          #@result_hash = @result_hash.merge!(tmp_hash)
+
+
+          puts "=========================================================="      if $DEBUG
+          puts "Loading "+file_name.to_s.capitalize+"\n"                         if $DEBUG
+          puts YAML.load(File.read("#{full_path_file_name}"))                    if $DEBUG
+          puts "__________________________________________________________"      if $DEBUG
+
+        end
+
+        puts "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-"         if $DEBUG
+        puts "The Main Hash: \n"+@result_hash.inspect.to_s                       if $DEBUG
+        puts "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-\n"       if $DEBUG
+
+        return @result_hash
+      end
+
+      def create_on_filesystem(route_name,optionable_file_mod="w",optionable_data=nil)
+        begin
+
+          #file_name generate
+          if !route_name.to_s.split(File::SEPARATOR).last.nil? || route_name.to_s.split(File::SEPARATOR).last != ''
+            file_name = route_name.to_s.split(File::SEPARATOR).last
+          else
+            file_name = nil?
+          end
+                    
+          #path_way
+          begin
+            raise ArgumentError, "missing route_name: #{route_name}"   if route_name.nil?
+            path = File.expand_path(route_name).to_s.split(File::SEPARATOR)
+            path = path - [File.expand_path(route_name).to_s.split(File::SEPARATOR).last]
+            path.shift
+          end
+
+          #job
+          begin
+            if !Dir.exists?(File::SEPARATOR+path.join(File::SEPARATOR))
+
+              at_now = File::SEPARATOR
+              path.each do |dir_to_be_checked|
+
+                at_now += "#{dir_to_be_checked+File::SEPARATOR}"
+                Dir.mkdir(at_now) if !Dir.exists?(at_now)
+
+              end
+            end
+          end
+
+          #file_create
+          File.new("#{File::SEPARATOR+path.join(File::SEPARATOR)+File::SEPARATOR}#{file_name}", optionable_file_mod ).write optionable_data
+
+        rescue Exception => ex
+          puts ex
+        end
+      end
+
+      def clone_mpath(original_path,new_name)
+        log_path = File.expand_path(original_path)
+        log_path = log_path.split(File::SEPARATOR)
+        log_path.pop
+        log_path.push(new_name)
+        log_path = log_path.join(File::SEPARATOR)
+        return log_path
+      end
+
+    end
+  end
+
+  ### Config
+  begin
+    class App
+      class << self
+        attr_accessor :log_path,
+                      :pid_path,
+                      :daemon_stderr,
+                      :exceptions,
+                      :exlogger,
+                      :app_name,
+                      :port,
+                      :terminate
+      end
+    end
+  end
+
+  ### Default
+  begin
+    App.log_path   = "./var/log/logfile.log"
+    App.pid_path   = "./var/pid/pidfile.pid"
+    #App.terminate  = false
+    #App.port       = 80
+    App.app_name   = $0
+
+    begin
+      ['daemon_stderr','exceptions','exlogger'].each do |one_log|
+
+        App.__send__(one_log+"=",clone_mpath(App.log_path,one_log+".log"))
+
+      end
+    end
+
+  end
+
+end

data/lib/clone/helpers/local_methods.rb

@@ -0,0 +1,150 @@
+#monkey patch
+begin
+  ### find and replace given targets
+  def process_running?(input)
+    Clone.process_running?(input)
+  end
+  def require_directory(directory,*args)
+    Clone.load_directory(directory,{:monkey_patch => 1},*args)
+  end
+  def require_ymls(directory)
+    Clone.load_ymls(
+        directory,
+        {:monkey_patch => 1}
+    )
+  end
+  def get_port(port,max_port=65535 ,host="0.0.0.0")
+    Clone.get_port(port,max_port,host)
+  end
+  def exlogger(error_msg,*args)
+    arg=Hash[*args]
+    arg[:prefix] = String.new                if arg[:prefix].nil?
+    arg[:path]   = Clone::App.exlogger  if arg[:path].nil?
+    Clone.create_on_filesystem arg[:path],
+                                    'a+'
+    Clone.error_logger(error_msg,arg[:prefix],arg[:path])
+  end
+  class Exception
+    def logger
+      Clone.create_on_filesystem Clone::App.exceptions,
+                                      'a+'
+      Clone.error_logger(self.backtrace,self,Clone::App.exceptions)
+    end
+  end
+  class File
+    def self.new!(file,optionable_data=nil,optionable_file_mod="w")
+      Clone.create_on_filesystem file,
+                                      optionable_file_mod,
+                                      optionable_data
+    end
+    def self.create(*args)
+      arg = Hash[*args]
+
+      begin
+
+        ### Validation
+        raise ArgumentError, "invalid or missing path!" if arg[:path].nil? || arg[:path].to_s.length <= 0
+        route_name = arg[:path]
+
+        if arg[:file_mod].nil?
+          optionable_file_mod="w"
+        else
+          optionable_file_mod=arg[:file_mod]
+        end
+
+        if arg[:data].nil?
+          optionable_data=nil
+        else
+          optionable_data=arg[:data]
+        end
+
+      end
+
+      Clone.create_on_filesystem route_name,
+                               optionable_file_mod,
+                               optionable_data
+    end
+  end
+  class Class
+    def class_methods
+      self.methods - Object.methods
+    end
+    def self.class_methods
+      self.methods - Object.methods
+    end
+  end
+  class Rnd
+    class << self
+      def string(length,amount=1)
+        mrg = String.new
+        first_string = true
+        amount.times do
+          a_string = Random.rand(length)
+          a_string == 0 ? a_string += 1 : a_string
+          mrg_prt  = (0...a_string).map{ ('a'..'z').to_a[rand(26)] }.join
+          first_string ? mrg += mrg_prt : mrg+= " #{mrg_prt}"
+          first_string = false
+        end
+        return mrg
+      end
+      def integer(length)
+        Random.rand(length)
+      end
+      def boolean
+        rand(2) == 1
+      end
+      def date from = Time.at(1114924812), to = Time.now
+        rand(from..to)
+      end
+    end
+  end
+  class Array
+    def index_of(target_element)
+      array = self
+      hash = Hash[array.map.with_index.to_a]
+      return hash[target_element]
+    end
+    def pinch n=1
+      return self[0..(self.count-2)]
+    end
+  end
+  class Hash
+    #pass single or array of keys, which will be removed, returning the remaining hash
+    def remove!(*keys)
+      keys.each{|key| self.delete(key) }
+      self
+    end
+    #non-destructive version
+    def remove(*keys)
+      self.dup.remove!(*keys)
+    end
+  end
+  class String
+    def positions(oth_string)
+
+      special_chrs=%w[# _ & < > @ $ . , -]+[*(0..9)]+[*("A".."Z")]+[*("a".."z")]
+      loop do
+        if oth_string.include? special_chrs[0]
+          special_chrs.shift
+        else
+          break
+        end
+      end
+
+      string=self
+      return_array = Array.new
+      loop do
+        break if string.index(oth_string).nil?
+        range_value= ((string.index(oth_string))..(string.index(oth_string)+oth_string.length-1))
+        return_array.push range_value
+        [*range_value].each do |one_index|
+          string[one_index]= special_chrs[0]
+        end
+      end
+
+      ### return value
+      return return_array
+    end
+  end
+
+end