random_data_despegar 2.1

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+
+RDoc::Task.new do |rdoc|
+end
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]
+task :default => :test

data/config/website.yml

@@ -0,0 +1,2 @@
+host: subelsky@rubyforge.org
+remote_dir: /var/www/gforge-projects/random-data/

data/lib/random_data_despegar.rb

@@ -0,0 +1,69 @@
+dir = "#{File.dirname(__FILE__)}/random_data_despegar"
+#----dependencies-----#
+require "securerandom"
+
+require "#{dir}/array_randomizer"
+require "#{dir}/booleans"
+require "#{dir}/contact_info"
+require "#{dir}/dates"
+require "#{dir}/locations"
+require "#{dir}/names"
+require "#{dir}/numbers"
+require "#{dir}/invoice_data"
+require "#{dir}/id_generator"
+require "#{dir}/text"
+require "#{dir}/markov"
+require "#{dir}/grammar"
+require "#{dir}/version"
+
+class Random
+  extend RandomDataDespegar::Booleans
+  extend RandomDataDespegar::ContactInfo
+  extend RandomDataDespegar::Dates
+  extend RandomDataDespegar::Grammar
+  extend RandomDataDespegar::Locations
+  extend RandomDataDespegar::Names
+  extend RandomDataDespegar::Numbers
+  extend RandomDataDespegar::InvoiceData
+  extend RandomDataDespegar::IdGenerator
+  extend RandomDataDespegar::Text
+
+  # Looks for a file in the load path with the name methodname.dat, reads the lines from that file, then gives you a random line from that file.
+  # Raises an error if it can't find the file.  For example, given a file named "horse.dat" in your load path:
+  # >> Random.horse
+  # => "Stallion"
+  # >> Random.horse
+  # => "Pony"
+  # >> Random.horse
+  # => "Mare"
+  # >> Random.horse
+  # => "Clydesdale"
+  # >> Random.horse
+  # => "Stallion"
+  # >> Random.horse
+  # => "Mare"
+
+  def self.method_missing(methodname)
+    thing = "#{methodname}.dat"
+    filename = find_path(thing)
+
+    if filename.nil?
+      super
+    else
+      array = []
+      File.open(filename, 'r') { |f| array = f.read.split(/[\r\n]+/) }
+      return array.rand
+    end
+  end
+
+  private
+
+  def self.find_path(filename)
+    $:.each do |path|
+      new_path = File.join(path,filename)
+      return new_path if File.exist?(new_path)
+    end
+    return nil
+  end
+
+end

data/lib/random_data_despegar/array_randomizer.rb

@@ -0,0 +1,67 @@
+# Extends the Array class with a function used to randomly choose elements.  Note that if you are using Rails, ActiveSupport recently was updated to include a similar
+# function.  This code checks for the presence of that method and does not try to replace it.  They work the same though so no worries.
+
+module RandomDataDespegar
+  module ArrayRandomizer
+  
+    # Randomly chooses an element from an array
+    # >> [1,2,3].rand = 3 
+    # [].rand = nil
+
+    def rand
+      return self[Kernel.rand(self.size)]
+    end
+
+    # Takes an array of non-negative weights
+    # and returns the index selected by a 
+    # roulette wheel weighted according to those
+    # weights.
+    # If a block is given then k is used to determine
+    # how many times the block is called.  In this
+    # case nil is returned.
+    def roulette(k=1)
+      wheel = []
+      weight = 0
+      # Create the cumulative array.
+      self.each do |x|
+        raise "Illegal negative weight #{x}" if x < 0
+        wheel.push(weight += x)
+      end
+      # print "wheel is #{wheel.inspect}\n";
+      # print "weight is #{weight.inspect}\n";
+      raise "Array had all zero weights" if weight.zero?
+      wheel.push(weight + 1) #Add extra element
+      if block_given?
+        k.times do 
+          r = Kernel.rand() # so we don't pick up that from array.
+          # print "r is #{r.inspect}\n";
+          roll = weight.to_f * r
+          # print "roll is #{roll.inspect}\n";
+          0.upto(self.size - 1) do |i|
+            if wheel[i+1] > roll
+              yield i 
+              break
+            end # if
+          end # upto
+        end # if block_given?
+        return nil
+      else
+        r = Kernel.rand() # so we don't pick up that from array.
+        # print "r is #{r.inspect}\n";
+        roll = weight.to_f * r
+        # print "roll is #{roll.inspect}\n";
+        0.upto(self.size - 1) do |i|
+          return i if wheel[i+1] > roll
+        end
+      end
+    end
+
+  end
+
+end
+
+unless Array.respond_to?(:rand)
+  Array.send :include, RandomDataDespegar::ArrayRandomizer
+end
+
+

data/lib/random_data_despegar/booleans.rb

@@ -0,0 +1,10 @@
+module RandomDataDespegar
+  
+  module Booleans
+    #Returns true or false randomly
+    def boolean
+      rand(2) == 1 ? true : false
+    end
+  end
+  
+end

data/lib/random_data_despegar/contact_info.rb

@@ -0,0 +1,24 @@
+module RandomDataDespegar
+  # Methods for randomly generating contact data like phone numbers and e-mail addresses
+  
+  module ContactInfo
+
+   # Returns a randomly-generated string of digits that roughly resembles a US telephone number.  Not guaranteed to be a valid area code.
+   def phone
+     "#{rand(900) + 100}-#{rand(900)+100}-#{rand(10000)+1000}"
+   end
+
+   # Returns a randomly-generated string of digits that roughly resembles an international telephone number as dialed from the US.  
+   # Not guaranteed to be a valid number but just good enough to get some sample data going.
+   
+   def international_phone
+    "011-#{rand(100) + 1}-#{rand(100)+10}-#{rand(10000)+1000}"
+   end
+
+   # Returns an e-mail address of the form "{first_initial}{last_name}@{domain}"
+   def email 
+    domains = %w(yahoo.com gmail.com privacy.net webmail.com msn.com hotmail.com example.com privacy.net)
+    "#{(initial + lastname).downcase}\@#{domains.rand}"  
+   end
+ end
+end

data/lib/random_data_despegar/dates.rb

@@ -0,0 +1,101 @@
+require 'date'
+
+module RandomDataDespegar
+
+  # Defines methods for random date generation
+
+  module Dates
+
+    # Returns a random date.
+    # If dayrange is an Integer,
+    # then the date returned will be at least
+    # what you specify from today.
+    # If dayrange is a range,
+    # you'll get a date between
+    # dayrange.min from today and dayrange.max from today.
+    # dayrange will be an integer or a range
+    #
+    def date(dayrange=45)
+      if dayrange.is_a?(Range)
+        offset = rand(dayrange.max-dayrange.min) + dayrange.min
+      else
+        offset = rand(dayrange*2) + dayrange
+      end
+      Date.today + offset
+    end
+
+    # Returns a date within the specified Range. The Range can be Date or String objects.
+    #
+    # Example:
+    # min = Date.parse('1966-11-15')
+    # max = Date.parse('1990-01-01')
+    # Random.date(min..max) # => a Date between 11/15/1996 and 1/1/1990
+    # Random.date('1966-11-15'..'1990-01-01') # => a Date between 11/15/1996 and 1/1/1990
+    #
+    def date_between(range)
+      min_date = range.min.is_a?(Date) ? range.min : Date.parse(range.min)
+      max_date = range.max.is_a?(Date) ? range.max : Date.parse(range.max)
+      diff = (max_date - min_date).to_i
+      min_date + rand(diff)
+    end
+
+    # Returns valid departure and return dates (Date and formated)
+    # Dates will be about 2/3 month from now,
+    # and stay will be between 5 and 20 days.
+    # departure_date_range will be a range
+    #
+    def departure_and_return_dates (departure_date_range=60..90)
+      stay = rand(5..20)
+      departure_date = Date.today + rand(departure_date_range)
+      return_date = departure_date + stay
+      {
+      :departure_date => departure_date,
+      :return_date => return_date,
+      :formated_departure_date => departure_date.strftime("%F"),
+      :formated_return_date => return_date.strftime("%F")
+      }
+    end
+
+    # Returns a hash with birhdate for a specific passenger type: adult, child or infant.
+    # Each passenger has: an age, month of birth and day of birth.
+    #
+    def passenger_birthdate (passenger_type)
+      present_year = Date.today.year
+      month = rand(1..12)
+      case
+        when passenger_type.eql?("adult") then
+          adt_age = rand(19..60)
+          month_adt_days = Date.new(present_year-adt_age,month,-1).day
+          adult = {
+            :age => adt_age,
+            :month => month,
+            :day => rand(1..month_adt_days)
+                   }
+        when passenger_type.eql?("child") then
+          chd_age = rand(3..5)
+          month_chd_days = Date.new(present_year-chd_age,month,-1).day
+          child = {
+            :age => chd_age,
+            :month => month,
+            :day => rand(1..month_chd_days)
+                   }
+        when passenger_type.eql?("infant") then
+          inf_age = rand(0..2)
+          month_inf_days = Date.new(present_year-inf_age,month,-1).day
+          infant = {
+            :age => inf_age,
+            :month => month,
+            :day => rand(1..month_inf_days)
+                    }
+      end
+    end
+
+    # Returns 2016-02-26T09:16:13Z
+    def passenger_birthdate_parsed(passenger_type)
+      pax_data = passenger_birthdate(passenger_type)
+      now = Time.now.utc.to_date
+      pax_data[:b_year] = now.year - pax_data[:age]
+      DateTime.new(pax_data[:b_year], pax_data[:month], pax_data[:day]).strftime('%FT%TZ')
+    end
+  end
+end

data/lib/random_data_despegar/grammar.rb

@@ -0,0 +1,61 @@
+
+module RandomDataDespegar
+  
+  # Defines methods for the generation of random data based on a supplied grammar.
+  
+  module Grammar
+  
+    # Returns simple sentences based on a supplied grammar, which must be a hash, the
+    # keys of which are symbols.  The values are either an array of successive values or a grammar 
+    # (i.e, hash with symbols as keys, and hashes or arrays as values.  The arrays contain symbols 
+    # referencing the keys in the present grammar, or strings to be output. The keys are always symbols.
+    #
+    # Example:
+    # Random.grammatical_construct({:story => [:man, " bites ", :dog], :man => { :bob => "Bob"}, :dog => {:a =>"Rex", :b =>"Rover"}}, :story)
+    # => "Bob bites Rover"
+    
+    def grammatical_construct(grammar, what=nil)
+      output = ""
+      if what.nil?
+        case grammar
+        when Hash
+          a_key = grammar.keys.sort_by{rand}[0]
+          output += grammatical_construct(grammar, a_key)
+        when Array
+          grammar.each do |item|
+            output += grammatical_construct(item)
+          end
+        when String
+          output += grammar
+        end
+      else
+        rhs = grammar[what]
+        case rhs
+        when Array
+          rhs.each do |item|
+            case item
+            when Symbol
+              output += grammatical_construct(grammar,item)
+            when String
+              output += item
+            when Hash
+              output += grammatical_construct(item)
+            else
+              raise "#{item.inspect} must be a symbol or string or Hash"
+            end
+          end
+        when Hash
+          output+= grammatical_construct(rhs)
+        when Symbol
+          output += grammatical_construct(rhs)
+        when String
+          output += rhs
+        else
+          raise "#{rhs.inspect} must be a symbol, string, Array or Hash"
+        end
+      end
+      return output
+    end
+
+  end
+end

data/lib/random_data_despegar/id_generator.rb

@@ -0,0 +1,137 @@
+module RandomDataDespegar
+  module IdGenerator
+    # cr ec pa pe ve mx co cl ar br
+    def id_for(site)
+      site ||= "generic"
+      self.send("generate_id_for_#{site.downcase}")
+    end
+
+    # Valido 20314562222
+    def argentinean_cuil(gender = "m", dni = "31456222")
+      generate_cuil(gender, dni)
+    end
+
+private
+    def generate_id_for_ar
+      generate_dni
+    end
+
+    def generate_id_for_br
+      cpf
+    end
+
+    def generate_id_for_cl
+      generate_rut
+    end
+
+    def generate_id_for_generic
+      Random.number_with_size(8)
+    end
+
+
+    # CPF valido 625.664.266-00
+    #
+    def cpf
+      n = ""
+      until check_cpf(n)
+        return n = 11.times.map{rand(0..9)}.join.to_s
+      end
+    end
+    # CHILEAN RUT
+    # valido DEPRECATED
+    def generate_rut
+      generate_chilean_rut
+    end
+
+    # Valido 5.954.720-8 59547208
+    def rut
+      generate_chilean_rut
+    end
+
+    def check_cpf(cpf=nil)
+     return false if cpf.nil?
+      winvalidos = %w{12345678909 11111111111 22222222222 33333333333 44444444444 55555555555 66666666666 77777777777 88888888888 99999999999 00000000000}
+      wvalor = cpf.scan /[0-9]/
+      if wvalor.length == 11
+        unless winvalidos.member?(wvalor.join)
+          wvalor = wvalor.collect{|x| x.to_i}
+          wsoma = 10*wvalor[0]+9*wvalor[1]+8*wvalor[2]+7*wvalor[3]+6*wvalor[4]+5*wvalor[5]+4*wvalor[6]+3*wvalor[7]+2*wvalor[8]
+          wsoma = wsoma - (11 * (wsoma/11))
+          wresult1 = (wsoma == 0 or wsoma == 1) ? 0 : 11 - wsoma
+          if wresult1 == wvalor[9]
+            wsoma = wvalor[0]*11+wvalor[1]*10+wvalor[2]*9+wvalor[3]*8+wvalor[4]*7+wvalor[5]*6+wvalor[6]*5+wvalor[7]*4+wvalor[8]*3+wvalor[9]*2
+            wsoma = wsoma - (11 * (wsoma/11))
+            wresult2 = (wsoma == 0 or wsoma == 1) ? 0 : 11 - wsoma
+            return true if wresult2 == wvalor[10] # CPF validado
+          end
+        end
+      end
+     return false # CPF invalidado
+    end
+
+    def generate_chilean_rut
+      run = (rand * 20000000).round + 5000000
+
+      suma = 0
+      mul = 2
+      run.to_s.reverse.split('').each do |i|
+        suma = suma + i.to_i * mul
+        if mul == 7
+          mul = 2
+        else
+          mul += 1
+        end
+      end
+      res = suma % 11
+
+      if res == 1
+        return "#{run}k"
+      elsif res == 0
+        return "#{run}0"
+      else
+        return "#{run}#{11-res}"
+      end
+    end
+
+    # TO DO - Ver de hacer un generador real
+    # DNI Valido 31222333
+    #
+    def generate_dni
+      "#{rand(10..38)}#{rand(100..800)}#{rand(100..800)}"
+    end
+
+    # CUIL válido 20311412095
+    def generate_cuil(sexo, nro_dni)
+        dniStc = nro_dni.to_s.rjust 8, "0"
+        xyStc = 30
+        xyStc = 27 if sexo == "f"
+        xyStc = 20 if sexo == "m"
+        cDocum = xyStc.to_s + dniStc
+        matriz = [5,4,3,2,7,6,5,4,3,2]
+        xx = 0
+        10.times do |t|
+            xx += cDocum[t].chr.to_i * matriz[t]
+        end
+        n = 11 - xx % 11
+        if n == 10
+            if (xyStc == 20 or xyStc == 27 or xyStc == 24)
+                xyStc, digitoStc = 23, 9
+            else
+                xyStc, digitoStc = 33, 9
+            end
+            digitoStc = 4 if xyStc == 27
+        else
+            digitoStc = (n == 11) ? 0 : n
+        end
+        return xyStc.to_s + dniStc + digitoStc.to_s
+    end
+
+    alias_method :generate_id_for_cr, :generate_id_for_generic
+    alias_method :generate_id_for_ec, :generate_id_for_generic
+    alias_method :generate_id_for_pa, :generate_id_for_generic
+    alias_method :generate_id_for_pe, :generate_id_for_generic
+    alias_method :generate_id_for_ve, :generate_id_for_generic
+    alias_method :generate_id_for_mx, :generate_id_for_generic
+    alias_method :generate_id_for_co, :generate_id_for_generic
+  end
+end