framework_gem 0.1.0

data/lib/tools/find_duplicate_rois.rb

@@ -0,0 +1,27 @@
+METHODS = []
+
+def find_duplicates(dir)
+  Dir.entries(dir).reject {|f| f.start_with?('.')}.each do |f|
+    path = File.join(dir, f)
+    if File.directory?(path)
+      find_duplicates(path)
+    elsif path.end_with?('.rb')
+      # find duplicate methods in .rb files
+      text = File.open(path, 'rb') {|file| file.read}
+      file_methods = text.scan(/^\s*def\s+([^\s\(]+)[\s\(]/).flatten
+      file_methods.each do |m|
+        if METHODS.include?(path + m)
+          puts "DUPLICATE METHOD IN FILE: #{path} : #{m}"
+        else
+          METHODS << (path + m)
+        end
+      end
+    end
+  end
+end
+
+begin
+  ARGV.each {|dir| find_duplicates(dir)}
+rescue => e
+  puts "ERROR: #{e.message}\n#{e.backtrace.join("\n\t")}"
+end

data/lib/tools/roku/inspector.rb

@@ -0,0 +1,130 @@
+require '../../lib/platform_libs/roku/roku_controller'
+require 'net/http'
+require 'json'
+
+class Inspector
+
+  attr_accessor(:ignore, :max_depth)
+  def initialize(args = {})
+    @max_depth = args.fetch(:max_depth, 99)
+    @ignore = args.fetch(:ignore, [])
+    @previous_nodes = {}
+  end
+
+
+  # Public: Create a json tree structure from data retrieved from the internal agent
+  #   of a Roku device
+  #
+  # r - rokuController which handles the connection
+  # elementName - starting branch of the tree currently appended to the end of https:<device_ip>/twctvweb/status/activewindow
+  # depth - how deep to go when traversing the tree: going too deep may cause the box to crash
+  def crawl(r, elementName, depth = 1)
+
+    puts ("crawl url = \"#{elementName}\"  -- depth =  #{depth}")
+    if (depth > max_depth)
+      return nil
+    end
+    s = r.get_text_t(elementName, 1)
+
+    if s.nil?
+      puts "..."
+      return
+    else
+      s = s.gsub('""+chr(34)+""', '""')
+      s = s.gsub('"+chr(34)+"', '')
+      puts s
+    end
+
+    begin
+      parsed = JSON.parse(s)
+      # puts parsed
+    rescue => e
+      puts 'whoops'
+      parsed = {}
+    end
+
+
+    # expand each element in an array
+    # !!!! BE CAREFUL !!!!!
+    # attempting to index an array element that does not exist will cause the app in the stb to crash
+    if (parsed.is_a? (Array))
+      puts "====  processing an array ====="
+      xxx = Array.new
+      parsed.each_with_index  do |v, i|
+        if (v != "roArray"  &&  v != 'roAssociativeArray' )
+          break
+        end
+        xxx.push(crawl r,"#{elementName}/index_#{i}", depth + 1)
+      end
+      parsed = xxx
+    else
+      parsed.each do |k, v|
+        if v.nil?
+          puts 'index roAssociativeArray'
+        else
+          if k.nil?
+            puts "..."
+          end
+          puts "#{k}       #{v}"
+
+          if (v == 'roAssociativeArray'  ||  v == "roArray")
+            puts "===== expand #{k} ======"
+            if ignore_it k.to_s
+              puts "===== skipping #{k}  ======"
+              next
+            end
+            if (@previous_nodes["#{k}"].nil?)
+              @previous_nodes["#{k}"] = "#{elementName}"
+              if (v == 'roAssociativeArray')
+                mydepth = depth + 1
+              else
+                mydepth = depth
+              end
+              parsed[k] = crawl r, "#{elementName}/#{k}", mydepth
+            else
+              msg = "object #{k} previously encountered at " + @previous_nodes["#{k}"]
+              parsed[k] = msg
+            end
+          end
+        end
+        puts "*** #{k} - " + v.inspect
+
+      end
+    end
+    parsed
+  end
+
+
+
+  # Public: specify an array of strings which should not be traversed
+  #
+  # what - the array of strings which will not be traversed
+  def ignore_it what
+    @ignore.each do |x|
+      if what == x
+        puts "ignoring #{x}"
+        return true
+      end
+    end
+    return false
+  end
+
+
+  def mainline
+    r = RokuController.new(:host => "192.168.0.2", :port=>8888)
+#    s = crawl r, "twc/channels"
+    s = crawl r, ""
+    puts s.to_json()
+  end
+
+
+end
+
+# Inspector.new.mainline
+
+inspector = Inspector.new
+
+# puts "ignore it " + inspector.ignore_it("gibberish").to_s
+# puts "ignore it " + inspector.ignore_it("twc").to_s
+
+# inspector.mainline

data/lib/tools/syntax_checker.rb

@@ -0,0 +1,83 @@
+# The SyntaxChecker class is used to validate new/updated scripts and methods.
+
+class SyntaxChecker
+
+  # Public: Check the specified Ruby file.
+  #
+  # type - Symbol type of file; can be: :script, :code.
+  # path - String path to file to check.
+  #
+  # Returns nothing.
+  # Raises an exception if check failed.
+  def check_file(type, path)
+    begin
+      case type
+        when :script
+          check_script(path)
+        when :code
+          check_code(path)
+        else
+          # Just load the file
+          load path
+      end
+    rescue Exception => e
+      STDERR.puts e.message
+      exit(1)
+    end
+  end
+
+  private
+
+  # Internal: Fetches all unique public, private, or standard methods.
+  def all_methods
+    (Module.public_methods + Module.private_methods + Module.methods).uniq
+  end
+
+  # Internal: Check the specified Ruby script.
+  #
+  # path - String path to script to check.
+  #
+  # Returns nothing.
+  # Raises an exception if script check failed.
+  def check_script(path)
+    require './lib/test_case/test_case.rb'
+    require './lib/test_case/functional_test_case.rb'
+    require './lib/test_case/performance_test_case.rb'
+    allowed_constants = Module.constants
+    allowed_methods = all_methods
+    load path  # always load AFTER preceding requires!
+    # Check methods and constants
+    all_methods.each do |m|
+      raise "Script file defines illegal method: #{m}" unless allowed_methods.include?(m)
+    end
+    tests_defined = 0
+    Module.constants.reject {|c| allowed_constants.include?(c)}.each do |c|
+      cls = Module.const_get(c)
+      # Only allow new subclasses of Functional or Performance TestCase
+      raise "Script file defines illegal constant: #{c}" unless cls.is_a?(Class)
+      raise "Script class #{c} is not a test case" unless cls < FunctionalTestCase || cls < PerformanceTestCase
+      tests_defined += 1
+      allowed_script_constants = TestCase.constants
+      cls.constants.each do |tc|
+        raise "Test class defines illegal constant: #{tc}" unless allowed_script_constants.include?(tc)
+      end
+      raise "`run' method not defined in test class" unless cls.instance_methods(false).include?(:run)
+    end
+    raise 'Test class not defined in script file' if tests_defined == 0
+    raise 'Multiple test classes defined in script file' if tests_defined > 1
+  end
+
+  # Internal: Check the specified Ruby code.
+  #
+  # path - String path to file containing code to check.
+  #
+  # Returns nothing.
+  # Raises an exception if code check failed.
+  def check_code(path)
+    load path
+  end
+
+end
+
+type, path = ARGV.first.split('=')
+SyntaxChecker.new.check_file(type.to_sym, path)

data/lib/upload_ref_images.rb

@@ -0,0 +1,255 @@
+require 'aws-sdk-s3'
+require 'io/console'
+
+DRY_RUN = ARGV.include?('--dry-run')
+TERSE_CHR = ARGV.include?('--terse') ? '.' : nil
+HELP = ARGV.any? { |a| ['--help', '--?', '-h'].include?(a) }
+SKIP = ARGV.include?('--skip')
+NO_CHECKOUT = ARGV.include?('--no-checkout')
+ARGV.clear
+
+# Print help if wanted
+if HELP
+    puts 'USAGE:    ruby upload_ref_images.rb [OPTIONS]'
+    puts 'OPTIONS:'
+    puts '          --dry-run           Do not upload or replace any images'
+    puts '          --terse             Do not show detailed progress'
+    puts '          --skip              Skip duplicate images'
+    puts '          --no-checkout       Do not reset/checkout/pull target branch'
+    puts '          --help, --?, -h     Show this help'
+    exit(0)
+end
+
+# Get AWS credentials
+print "\nAWS Access Key ID>"
+ENV['AWS_ACCESS_KEY_ID'] = STDIN.noecho(&:gets).chomp
+print "#{"*" * ENV['AWS_ACCESS_KEY_ID'].length}\nAWS Secret Access Key>"
+ENV['AWS_SECRET_ACCESS_KEY'] = STDIN.noecho(&:gets).chomp
+print "#{"*" * ENV['AWS_SECRET_ACCESS_KEY'].length}\n"
+ENV['AWS_REGION'] = 'us-east-1'
+
+def main
+    # Get workspaces
+    branch = `git rev-parse --abbrev-ref HEAD`.strip
+    existing_branches = `git ls-remote --heads`.scan(/refs\/heads\/([^\s]+)/).flatten
+    puts "Found workspaces: #{existing_branches.inspect}"
+    print "\nSource Workspace(s), comma-separated [#{branch}]>"
+    src_branches = gets.chomp
+    src_branches = src_branches.empty? ? [branch] : src_branches.split(',').map {|b| b.strip}
+    src_branches.map! {|b| [b.split('@')[0], b.split('@')[1]]}
+    src_branches.each do |branch, _|
+        unless existing_branches.include?(branch)
+            raise "Source workspace [#{branch}] does not exist."
+        end
+    end
+    dst_branch = nil
+    if src_branches.count == 1
+        # if only one source, allow choosing same or different destination
+        print "Destination Workspace [#{src_branches.first[0]}]>"
+        dst_branch = gets.chomp
+        if dst_branch.empty?
+            dst_branch = src_branches.first[0]
+        else
+            unless existing_branches.include?(dst_branch)
+                raise "Destination workspace [#{dst_branch}] does not exist."
+            end
+        end
+    end
+
+    summary = {}
+    src_branches.each do |workspace, ref|
+        summary[workspace] = {}
+        start = Time.now
+        errors = {}
+        skipped = 0
+        replaced = 0
+        uploaded = 0
+        min_bytes = 0
+        max_bytes = 0
+        total_bytes = 0
+        begin
+            unless NO_CHECKOUT
+                # Switch to workspace
+                `git reset --hard`
+                `git checkout #{ref.nil? ? workspace : ref}`
+                if ref.nil?
+                    `git pull --ff-only`
+                end
+            end
+
+            # Connect and check bucket
+            bucket = 'tmc-ref-images'
+            prefix = "media/#{dst_branch.nil? ? workspace : dst_branch}"
+            s3 = Aws::S3::Resource.new
+            b = s3.bucket(bucket)
+            unless b.exists?
+                raise "Bucket '#{bucket}' does not exist."
+            end
+            remote_img_files = []
+            marker = nil
+            loop do
+                new_objects = b.objects(marker: marker, prefix: prefix + '/')
+                count = 0
+                new_objects.each do |o|
+                    count += 1
+                    remote_img_files << o.key
+                end
+                break if count == 0
+                marker = remote_img_files.last
+            end
+
+            # Discover ref images in branch
+            ref_img_files = Dir["./tsimages/reference/**/*"].reject { |p| File.directory?(p) }
+            if ref_img_files.empty?
+                raise 'No reference images found. This script must be run at the top level of the repo.'
+            end
+            puts "\nFound #{ref_img_files.count} ref images in workspace #{workspace}."
+            if workspaces.count == 1
+                print "Continue#{DRY_RUN ? ' with dry run' : ''}? [Yes]>"
+                answer = gets.chomp
+                if !answer.empty? && answer.match(/(?i)y(es)?/).nil?
+                    puts "Aborted."
+                    exit(0)
+                end
+                puts
+            end
+            # Launch thread to show progress
+            progress = Thread.new do
+                until Thread.current[:stop?]
+                    if Thread.current[:show?]
+                        print TERSE_CHR || '='
+                        sleep 1
+                    else
+                        sleep 0.25
+                    end
+                end
+            end
+            # Upload ref images
+            begin
+                start = Time.now
+                ref_img_files.each_with_index do |path, i|
+                    ext_fix = nil
+                    index_str = "#{i + 1}/#{ref_img_files.count}"
+                    action = 'Uploading'
+                    log_skip = lambda { print TERSE_CHR || "[#{index_str}] Skipping: #{path}\n" }
+                    key = path.sub(/^.*tsimages\/reference/, prefix)
+                    unless key.match?(/(?i)\.jpg$/)
+                        p1 = path.sub('./', '')
+                        p2 = File.extname(p1) == '' ? p1 + '.jpg' : p1.sub(File.extname(p1), '.jpg')
+                        ext_fix = [p1, p2.downcase]
+                        key = File.extname(key) == '' ? key + '.jpg' : key.sub(File.extname(key), '.jpg')
+                    end
+                    if remote_img_files.include?(key)
+                        if key.downcase != key
+                            o.delete unless DRY_RUN
+                            action = 'Replacing'
+                            replaced += 1
+                        elsif SKIP
+                            log_skip.call
+                            skipped += 1
+                            next
+                        end
+                    end
+                    key.downcase!
+                    if SKIP && remote_img_files.include?(key)
+                        log_skip.call
+                        skipped += 1
+                        next
+                    end
+                    bytes = File.size(path)
+                    print "[#{index_str}] #{action} #{get_readable_size(bytes)}: #{path} " if TERSE_CHR.nil?
+                    unless DRY_RUN
+                        # Do upload
+                        begin
+                            progress[:show?] = true
+                            o = b.object(key)
+                            o.upload_file(Pathname.new(path), content_type: 'image/jpeg')
+                            print "> #{o.public_url}" if TERSE_CHR.nil?
+                            uploaded += 1
+                            min_bytes = bytes if bytes < min_bytes || min_bytes == 0
+                            max_bytes = bytes if bytes > max_bytes
+                            total_bytes += bytes
+                            progress[:show?] = false
+                            unless ext_fix.nil?
+                                cmd = %Q("C:\\Program Files\\Git\\bin\\bash.exe" -c "git grep -l '#{ext_fix[0]}'")
+                                matching_files = `#{cmd}`.strip.split(/\r?\n/)
+                                puts "\nMatched #{matching_files.count} files with: #{cmd}"
+                                matching_files.each do |f|
+                                    cmd = %Q("C:\\Program Files\\Git\\bin\\bash.exe" -c "perl -pi -e 's/#{ext_fix[0].gsub('/', '\\/') + '(?=[\\"\'\\\'\'])'}/#{ext_fix[1].gsub('/', '\\/')}/g' #{f}")
+                                    puts "#{cmd}"
+                                    `#{cmd}`
+                                end
+                            end
+                        rescue => e
+                            progress[:show?] = false
+                            errors[path] = e
+                        ensure
+                            progress[:show?] = false
+                        end
+                    end
+                    puts if TERSE_CHR.nil?
+                end
+            ensure
+                summary[workspace].update(
+                    total_sec: Time.now - start,
+                    errors: errors,
+                    skipped: skipped,
+                    replaced: replaced,
+                    uploaded: uploaded,
+                    min_bytes: min_bytes,
+                    max_bytes: max_bytes,
+                    total_bytes: total_bytes
+                )
+                progress[:stop?] = true
+                progress.join
+            end
+        rescue => e
+            summary[workspace][:error] = e
+        end
+    end
+
+    # Print results
+    src_branches.each do |workspace, _|
+        puts "\n\n=== Workspace Summary [#{workspace}] ==="
+        if summary[workspace][:error].nil?
+            skipped = summary[workspace][:skipped]
+            replaced = summary[workspace][:replaced]
+            total_bytes = summary[workspace][:total_bytes]
+            total_sec = summary[workspace][:total_sec]
+            uploaded = summary[workspace][:uploaded]
+            max_bytes = summary[workspace][:max_bytes]
+            min_bytes = summary[workspace][:min_bytes]
+            errors = summary[workspace][:errors]
+
+            puts "Skipped #{skipped} ref images."
+            puts "Replaced #{replaced} ref images."
+            bytes_per_sec = total_bytes / total_sec
+            avg_bytes = uploaded == 0 ? 0 : total_bytes / (uploaded * 1.0)
+            h = total_sec.round / 3600
+            m = (total_sec.round % 3600) / 60
+            s = (total_sec.round % 3600) % 60
+            puts "Uploaded #{uploaded} ref images in #{h.to_s.rjust(2, '0')}:#{m.to_s.rjust(2, '0')}:#{s.to_s.rjust(2, '0')} " +
+                "(#{get_readable_size(bytes_per_sec)}/s, total #{get_readable_size(total_bytes)}, min #{get_readable_size(min_bytes)} / " +
+                "max #{get_readable_size(max_bytes)} / avg #{get_readable_size(avg_bytes)})."
+            unless errors.empty?
+                puts "\nImage errors:\n#{errors.map { |p, e| "#{p} [#{e.message}]" }.join("\n")}"
+            end
+        else
+            e = summary[workspace][:error]
+            puts "Error: #{e.message}\n#{e.backtrace.join("\n")}"
+        end
+    end
+end
+
+# Gets a readable string for the given size in bytes.
+def get_readable_size(size_bytes)
+units = %w(B KB MB GB TB)
+    Array(0..units.length - 1).reverse.each do |i|
+        mult = 1000.0 ** i
+        if size_bytes >= (mult == 1 ? 0 : mult)
+            return "#{(size_bytes / mult).round(1)} #{units[i]}"
+        end
+    end
+end
+
+main