rubic-rb 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: db904df42fe403d01ef04fa7a020224a0ad7c313
+  data.tar.gz: 506372dcee6dffb831285455799d5255223f2409
+SHA512:
+  metadata.gz: 5b97aba8f32e4cfb57967380b5001e84e429925ea2ea1a37ad1f0e7082372442143403268a0011377f2868190e45b2f713bb77edcd3e36edd9d638a445c35906
+  data.tar.gz: ceb74f1e7044e6f847d99a3aeb03a21dd5f8cd2f3875793c728fc0e75e00d9b4167b18b45a35e1590b1f5e73a0fb506a1360decc1ef3d759030d62a4bf827e6b

data/rubic-gem/active.rb

@@ -0,0 +1,21 @@
+require 'bundler/setup'
+require 'active_record'
+require 'rubygems'
+​
+module Rubik
+  module Utils
+    class Active
+      def self.load(env)
+        project_root = File.expand_path('../../../', __FILE__)
+        Dir.glob(project_root + '/models/*.rb').each{|f| require f}
+​
+        connection_details = YAML.load File.read(File.join(File.expand_path('../../../config', __FILE__), 'database.yml'))
+        ActiveRecord::Base.establish_connection(connection_details[env])
+​
+        if __FILE__ == $0
+          Rubik::Logging.logger.info { "Count of Pages: #{Page.count}" }
+        end
+      end
+    end
+  end
+end

data/rubic-gem/downloader.rb

@@ -0,0 +1,39 @@
+require 'net/ftp'
+require 'net/http'
+​
+module Rubik
+  module Utils
+    class Downloader
+​
+      def self.download(url, dest, user=nil, pwd=nil)
+        uri   = URI.parse(URI.encode(url))
+        host  = uri.host
+        path  = File.dirname(uri.path)
+        file  = File.basename(uri.path)
+        return ftp_download(host, path, file, dest, user, pwd) if url.start_with?('ftp')
+        return http_download(host, path, file, dest, user, pwd) if url.start_with?('http')
+        raise 'Invalid url'
+      end
+​
+      def ftp_download(domain, remotedir, file, dest, user=nil, pwd=nil)
+        ftp = Net::FTP::new(domain)
+        ftp.passive = true
+        ftp.login(user, pwd) if user && pwd
+        ftp.chdir(remotedir)
+        ftp.getbinaryfile(file, dest, 1024)
+        ftp.close
+        return dest
+      end
+​
+      def http_download(domain, remotedir, file, dest, user=nil, pwd=nil)
+        Net::HTTP.start(domain) do |http|
+          resp = http.get("#{remotedir}/#{file}")
+          open(dest, "wb") do |file|
+            file.write(resp.body)
+          end
+        end
+        return dest
+      end
+    end
+  end
+end

data/rubic-gem/env_loader.rb

@@ -0,0 +1,15 @@
+require 'rubik/logging'
+require 'yaml'
+​
+module Rubik
+  module Utils
+    class EnvLoader
+      def self.load(env = 'local', path = './')
+        env_file = File.join(path, "#{env}_env.yml")
+        YAML.load(File.open(env_file)).each do |key, value|
+          ENV["#{key.to_s}"] = value
+        end if File.exists?(env_file)
+      end
+    end
+  end
+end

data/rubic-gem/file.rb

@@ -0,0 +1,36 @@
+module Rubik
+  module Utils
+    class File
+      def self.info(file)
+​
+        results = {}
+        encoding  = `nkf -g #{file}`.strip
+        encoding  = 'SJIS' if encoding == 'Shift_JIS'
+        results[:encoding] = encoding
+​
+        head  = `head -n 1 #{file}`
+        col_sep = (head.count("\t") >= head.count(",") ? "\t" : "," )
+        col_sep = (head.count(col_sep) >= head.count("|") ? col_sep : "|" )
+        results[:col_sep] = col_sep
+​
+        file_format = 'TSV'
+        file_format = 'CSV' if col_sep == ","
+        file_format = 'PSV' if col_sep == "|"
+        results[:file_format] = file_format
+​
+        quote_char = "\x00"
+        if `grep -m 1 '#{col_sep}"' #{file} | wc -l`.strip.to_i > 0
+          quote_char = "\""
+        end
+        if quote_char == "\x00" && `grep -m 1 "#{col_sep}'" #{file} | wc -l`.strip.to_i > 0
+          quote_char = "'"
+        end
+        if quote_char == "\x00" && `grep -m 1 '#{col_sep}|' #{file} | wc -l`.strip.to_i > 0
+          quote_char = "|"
+        end
+        results[:quote_char] = quote_char
+        return results
+      end
+    end
+  end
+end

data/rubic-gem/logging.rb

@@ -0,0 +1,46 @@
+require 'time'
+require 'logger'
+​
+module Rubik
+  module Utils
+    module Logging
+      class Pretty < Logger::Formatter
+        # Provide a call() method that returns the formatted message.
+        def call(severity, time, program_name, message)
+          "#{time.utc.iso8601} #{Process.pid} TID-#{Thread.current.object_id.to_s(36)}#{context} #{severity}: #{message}\n"
+        end
+​
+        def context
+          c = Thread.current[:rubik_context]
+          c ? " #{c}" : ''
+        end
+      end
+​
+      def self.with_context(msg)
+        Thread.current[:rubik_context] = msg
+        yield
+      ensure
+        Thread.current[:rubik_context] = nil
+      end
+​
+      def self.initialize_logger(log_target = STDOUT)
+        @logger = Logger.new(log_target)
+        @logger.level = Logger::INFO
+        @logger.formatter = Pretty.new
+        @logger
+      end
+​
+      def self.logger
+        @logger || initialize_logger
+      end
+​
+      def self.logger=(log)
+        @logger = (log ? log : Logger.new('/dev/null'))
+      end
+​
+      def logger
+        Rubik::Logging.logger
+      end
+    end
+  end
+end

data/rubic-gem/rule-2.rb

@@ -0,0 +1,56 @@
+module Rubik
+  module Rule
+    def self.validate_rule(row, rule)
+      if rule['type'] == 'string'
+        return false unless row[rule['field'].to_sym].instance_of? String
+        case rule['is']
+          when '=='
+            return row[rule['field'].to_sym] == rule['to']
+          when '!='
+            return row[rule['field'].to_sym] != rule['to']
+          when 'startsWith'
+            return row[rule['field'].to_sym].start_with? rule['to']
+          when '!startsWith'
+            return !(row[rule['field'].to_sym].start_with? rule['to'])
+          when 'endsWith'
+            return row[rule['field'].to_sym].end_with? rule['to']
+          when '!endsWith'
+            return !(row[rule['field'].to_sym].end_with? rule['to'])
+          when 'include'
+            return row[rule['field'].to_sym].include? rule['to']
+          when '!include'
+            return !(row[rule['field'].to_sym].include? rule['to'])
+        end
+      end
+      if rule['type'] == 'number'
+        return false unless row[rule['field'].to_sym].instance_of? Fixnum
+        return eval("#{row[rule['field'].to_sym]} #{rule['is']} #{rule['to']}")
+      end
+      return true
+    end
+​
+    def self.validate_row(row, rules)
+      rules.each do |rule|
+        return false unless Rubik::Rule::validate_rule(row, rule)
+      end
+      return true
+    end
+​
+    def self.augment_row(row, field_rules)
+      field_rules.keys.each do |name|
+        row[name] = field_rules[name]['default']
+        field_rules[name]['when'].each do |cond|
+          row[name] = cond['then'] if Rubik::Rule::validate_rule(row, cond)
+        end
+      end
+      row.keys.each do |key_1|
+        if (row[key_1].instance_of?(String) and row[key_1].include?('{{') and row[key_1].include?('}}'))
+          row.keys.each do |key_2|
+            row[key_1] = row[key_1].gsub("{{#{key_2.to_s}}}", row[key_2].to_s)
+          end
+        end
+      end
+      return row
+    end
+  end
+end

data/rubic-gem/storage.rb

@@ -0,0 +1,33 @@
+module Rubik
+  module Utils
+    class Storage
+      def self.download_from_s3(local_file, key, bucket)
+        service     = AWS::S3.new(:access_key_id => ENV['AWS_ACCESS_KEY_ID'], :secret_access_key => ENV['AWS_SECRET_ACCESS_KEY'])
+        object      = service.buckets[bucket].objects[key]
+        File.open(local_file, 'wb') do |file|
+          object.read do |chunk|
+            file.write(chunk)
+          end
+        end
+        return local_file
+      end
+​
+      def self.upload_to_s3(dest_file, key, bucket)
+        service = AWS::S3.new(:access_key_id => ENV['AWS_ACCESS_KEY_ID'], :secret_access_key => ENV['AWS_SECRET_ACCESS_KEY'])
+        service.buckets[bucket].objects[key].write(:file => dest_file)
+        return key
+      end
+​
+      def self.delete_from_s3(key, bucket)
+        service = AWS::S3.new(:access_key_id => ENV['AWS_ACCESS_KEY_ID'], :secret_access_key => ENV['AWS_SECRET_ACCESS_KEY'])
+        service.buckets[bucket].objects[key].delete
+        return key
+      end
+​
+      def self.list_from_s3(bucket)
+        service = AWS::S3.new(:access_key_id => ENV['AWS_ACCESS_KEY_ID'], :secret_access_key => ENV['AWS_SECRET_ACCESS_KEY'])
+        service.buckets[bucket].objects.map(&:key)
+      end
+    end
+  end
+end

data/rubic-gem/uploader.rb

@@ -0,0 +1,38 @@
+require 'net/ftp'
+require 'net/sftp'
+require 'net/scp'
+​
+module Rubik
+  module Utils
+    class Uploader
+​
+      def self.upload(file, settings)
+        host = URI.parse(settings.url).host
+        dir_name = File.dirname(URI.parse(settings.url).path)
+        return ftp_upload(file, host, dir_name, settings.username, settings.password) if settings.url.start_with?('ftp')
+        return scp_upload(file, host, dir_name, settings.username, settings.password) if settings.url.start_with?('scp')
+        return sftp_upload(file, host, dir_name, settings.username, settings.password) if settings.url.start_with?('sftp')
+        raise 'Invalid url'
+      end
+​
+      private
+​
+      def ftp_upload(file, host, dir_name, user=nil, pwd=nil)
+        Net::FTP.open(host, user, pwd) do |ftp|
+          ftp.chdir(dir_name)
+          ftp.putbinaryfile(file)
+        end
+      end
+​
+      def scp_upload(file, host, dir_name, user=nil, pwd=nil)
+        Net::SCP.upload!(host, user, file, dir_name, :password => pwd)
+      end
+​
+      def sftp_upload(file, host, dir_name, user=nil, pwd=nil)
+        Net::SFTP.start(host, user, :password => pwd) do |sftp|
+          sftp.upload!(file, dir_name)
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: rubic-rb
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- Bruno Quentin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-11 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- rubic-gem/active.rb
+- rubic-gem/downloader.rb
+- rubic-gem/env_loader.rb
+- rubic-gem/file.rb
+- rubic-gem/logging.rb
+- rubic-gem/rule-2.rb
+- rubic-gem/storage.rb
+- rubic-gem/uploader.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Rubic Gem
+test_files: []