require 'fileutils'

s2 = ['The_One_With_Rosss_New_Girlfriend','The_One_With_the_Breast_Milk','The_One_Where_Heckles_Dies',
	'The_One_With_Phoebes_Husband','The_One_With_Five_Steaks_and_an_Eggplant','The_One_With_the_Baby_on_the_Bus',
	'The_One_Where_Ross_Finds_Out','The_One_With_the_List','The_One_With_Phoebes_Dad','The_One_With_Russ',
	'The_One_With_The_Lesbian_Wedding','The_One_After_the_Superbowl_part_1','The_One_After_the_Superbowl_part_2',
	'The_One_With_The_Prom_Video','The_One_Where_Ross_and_Rachel_You_Know','The_One_Where_Joey_Moves_Out',
	'The_One_Where_Eddie_Moves_In','The_One_Where_Dr._Ramoray_Dies','The_One_Where_Eddie_Wont_Go',
	'The_One_Where_Old_Yeller_Dies','The_One_With_The_Bullies','The_One_With_Two_Parties',
	'The_One_With_The_Chicken_Pox','The_One_With_Barry_&_Mindys_Wedding']

shows = Dir.glob('/Users/kishansahadeo/Desktop/TVSHOWS/Friends/S2/*.mkv').sort

shows.each_with_index do |file, index|
	FileUtils.mv file, "#{File.dirname(file)}/#{File.basename(file,'.*')}" + "_" + s2[index] + ".mkv"
end

http_basic_authenticate_with :name => "frodo", :password => "thering", only: [:[metodo]]
skip_before_action :verify_authenticity_token, only: [:[metodo]]

def metodo
  render :json => {}, :status => :ok
end

def shortest_path(v,w)
  raise ArgumentError unless path?(v,w) to_edge = []
  bfs(w) { |v1,v2| to_edge[v2] = v1 } result = []
  x= v
  while x != w
    result << x
    x = to_edge[x]
  end
  result << x
end

def path?(v1,v2)
  return false if v1 < 0 or vertices <= v1
  return false if v2 < 0 or vertices <= v2
  dfs(v1) do |v,w|
    return true if w == v2
  end
  false 
end

def breadth_first_search(v)
  raise ArgumentError, "No such vertex" if v < 0 or
vertices <= v
  queue = LinkedQueue.new
  is_visited = []
  queue.enter(Edge.new(-1,v))
  while !queue.empty? do
    edge = queue.leave
    next if is_visited[edge.w]
    yield edge.v,edge.w
    is_visited[edge.w] = true
    each_edge(edge.w) do |w,x|
      queue.enter(Edge.new(w,x)) if !is_visited[x]
    end
end end

def depth_first_search(v)
  raise ArgumentError, "No such vertex" if v < 0 or
vertices <= v
  is_visited = []
  visit = lambda do |v|
    each_edge(v) do |v,w|
      next if is_visited[w]
      yield v,w
      is_visited[w] = true
      visit.call(w)
end end
  yield -1,v
  is_visited[v] = true
  visit.call(v)
end

#text_content = "string"

require "google/cloud/language"

language = Google::Cloud::Language.new

response = language.analyze_sentiment content: text_content, type: :PLAIN_TEXT

sentiment = response.document_sentiment

puts "Overall document sentiment: (#{sentiment.score})"
puts "Sentence level sentiment:"

sentences = response.sentences

sentences.each do |sentence|
  sentiment = sentence.sentiment
  puts "#{sentence.text.content}: (#{sentiment.score})"
end

response = RestClient::Request.new({
      method: :post,
      url: "[URL]",
      user: 'someone',
      password: 'mybirthday',
      payload: { post_this: 'some value', post_that: 'other value' },
      headers: { :accept => :json, content_type: :json }
    }).execute do |response, request, result|
      case response.code
      when 400
        [ :error, parse_json(response.to_str) ]
      when 200
        [ :success, parse_json(response.to_str) ]
      else
        fail "Invalid response #{response.to_str} received."
      end
    end

double_re = /\b(['A-Z]+) +\1\b/i

#!/usr/bin/env ruby

require 'fog'

client = ::Fog::Compute.new(
  :provider                     => 'vsphere',
  :vsphere_username             => '',
  :vsphere_password             => '',
  :vsphere_server               => '',
  :vsphere_expected_pubkey_hash => '',
)


interface_attrs = {
  network: 'LX-LAN-VLAN-775',
  type: 'VirtualE1000'
}

attrs = {
  :name => 'some.example.com',
  :memory_mb => '768',
  :interfaces => [ interface_attrs ],
  :volumes => [
    {
      :storage_pod => 'Some-Mirror-Pod',
      :name => 'Hard disk',
      :size_gb => '10',
      :thin => 'true',
      :eager_zero => 'false'
    }
  ],
  :scsi_controller=> {
    :type=>"VirtualLsiLogicController"
  },
  :datacenter => "Toledo",
  :boot_order => ["network", "disk"],
  :cpus => "1",
  :corespersocket => "1",
  :cluster=>"Some-Cluster",
  :resource_pool=>"default",
  :path => "/Datencenter/Some/path",
  :guest_id=>"rhel7_64Guest",
  :memoryHotAddEnabled=>"1",
  :cpuHotAddEnabled=>"1",
  :start=>"1",
  :annotation=>"test vm"
}

vm = client.servers.new(attrs)

vm.save

def percentile(arr, pcent)
  sorted = arr.sort

  # http://en.wikipedia.org/wiki/Percentile#Linear_interpolation_between_closest_ranks
  percent_ranks = (1..arr.length).map { |i| (100.0 / sorted.length) * ( i - 0.5) }

  if pcent < percent_ranks.first
    sorted[0]
  elsif pcent > percent_ranks.last
    sorted.last
  else
    idx = percent_ranks.find_index { |rank| rank == pcent }
    return sorted[idx] if idx != nil

    idx = rank_at = nil
    percent_ranks.each_with_index do |rank, i|
      if rank < pcent && pcent < percent_ranks[i+1]
        idx = i
        rank_at = rank
      end
    end
    sorted[idx] + (arr.length * (pcent-rank_at).to_f/100 * (sorted[idx+1] - sorted[idx]))
  end
end

def stats(arr)
  arr = arr.clone.extend(Stats)

  lowest = arr.min
  highest = arr.max
  total = arr.inject(:+)
  len = arr.length
  average = total.to_f / len # to_f so we don't get an integer result
  sorted = arr.sort
  variance = (arr.inject(0) {|accum, i| accum + (i-average)**2 }.to_f/(len))
  std_dev = Math.sqrt(variance)
  median = len % 2 == 1 ? sorted[len/2] : (sorted[len/2 - 1] + sorted[len/2]).to_f / 2
  {
    :min => lowest,
    :max => highest,
    :avg => average,
    :std_dev => std_dev,
    :med => median,
    :pct_50 => percentile(arr, 50),
    :pct_90 => percentile(arr, 90)
  }.tap do |stats|
    if (stats[:med]-stats[:pct_50]).abs > 0.000001
      raise "med was #{stats[:med].inspect} but 50% percenile was #{stats[:pct_50].inspect} for #{arr.inspect}}"
    end
  end
end


module Stats

  def sum
    self.inject(0){|accum, i| accum + i }
  end

  def mean
    self.sum/self.length.to_f
  end

  def sample_variance
    m = self.mean
    sum = self.inject(0){|accum, i| accum +(i-m)**2 }
    sum/(self.length - 1).to_f
  end

  def standard_deviation
    return Math.sqrt(self.sample_variance)
  end

end