tekido 1.0.0

data/lib/tekido/methods/boolean.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+module Tekido
+  module Methods
+    module ClassMethods
+      def yes?(percent = 50)
+        percent_as(:float) <= (percent.is_a?(Numeric) ? percent : 50)
+      end
+    end
+  end
+end
+

data/lib/tekido/methods/date.rb

@@ -0,0 +1,39 @@
+# coding: utf-8
+require "date"
+
+module Tekido
+  module Methods
+    module ClassMethods
+      def date(arg = nil)
+        min, max = nil, nil
+        if arg.nil?
+          min, max = Date.new(1, 1, 1), Date.new(9999, 12, 31)
+        elsif arg.is_a?(Integer)
+          min, max = Date.new(arg, 1, 1), Date.new(arg, 12, 31)
+        elsif arg.is_a?(Range)
+          if arg.min.is_a?(Integer)
+            min, max = Date.new(arg.min, 1, 1), Date.new(arg.max, 12, 31)
+          elsif arg.min.is_a?(Date)
+            min, max = arg.min, arg.max
+          end
+        end
+        min ? min + integer((max - min).to_i) : nil
+      end
+
+      def birthday(arg = nil)
+        if arg.nil?
+          min = (Date.today << 12 * 101) + 1
+          date(min..Date.today)
+        elsif arg.is_a?(Integer)
+          min = (Date.today << 12 * (arg + 1)) + 1
+          max = Date.today << 12 * arg
+          date(min..max)
+        elsif arg.is_a?(Range) && arg.min.is_a?(Integer)
+          min = (Date.today << 12 * (arg.max + 1)) + 1
+          max = Date.today << 12 * arg.min
+          date(min..max)
+        end
+      end
+    end
+  end
+end

data/lib/tekido/methods/numeric.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+module Tekido
+  module Methods
+    module ClassMethods
+      def integer(arg = nil)
+        if arg.nil?
+          max = 2 ** 30 - 1
+          rand(0..max)
+        else
+          rand(arg).to_i
+        end
+      end
+
+      def float(arg = nil)
+        if arg.nil?
+          rand
+        elsif arg.is_a?(Range)
+          rand(arg.min.to_f..arg.max.to_f)
+        else
+          rand * arg.to_f
+        end
+      end
+    end
+  end
+end

data/lib/tekido/methods/percentage.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+module Tekido
+  module Methods
+    module ClassMethods
+      def percent
+        percent_as(:integer)
+      end
+
+      def percent_as(type)
+        per = rand(0.0..100.0)
+        case type
+        when :float
+          per
+        when :integer
+          per.to_i
+        when :mo5
+          per.to_i / 5 * 5
+        when :deca, :mo10
+          per.to_i / 10 * 10
+        end
+      end
+    end
+  end
+end
+
+

data/lib/tekido/methods/string.rb

@@ -0,0 +1,64 @@
+# coding: utf-8
+module Tekido
+  module Methods
+    module ClassMethods
+      UPPER_CHARS = ('A'..'Z').to_a
+      LOWER_CHARS = ('a'..'z').to_a
+      NUMBER_CHARS = ('0'..'9').to_a
+      EXAMPLE_DOMAINS = ["example.com", "exmple.net", "example.org"] +
+                        ["example.jp", "example.co.jp", "example.ne.jp"] +
+                        (0..9).map { |i| ["example#{i}.jp", "example#{i}.co.jp", "example#{i}.ne.jp"] }.flatten
+
+      def string(options = {})
+        size = size_from(options[:size])
+        chars = chars_from(options[:chars], *options[:components])
+
+        "".tap do |str|
+          size.times do
+            str << chars.sample
+          end
+        end
+      end
+
+      def email(*bases)
+        local = string(size: 3..32, components: [:lower, :number])
+        domains = bases.empty? ? EXAMPLE_DOMAINS : bases.map { |b| b.index("@") ? b[b.index('@').to_i+1..b.size] : b }
+        "#{local}@#{domains.sample}"
+      end
+
+      private
+      def size_from(option)
+        base_size = integer(1..255)
+        if option.nil?
+          base_size
+        elsif option.is_a?(Integer)
+          option > 0 ? option : base
+        elsif option.is_a?(Range)
+          new_size = integer(option)
+          new_size > 0 ? new_size : base
+        end
+      end
+
+      def chars_from(chars, *components)
+        return chars if chars.is_a?(Array) && !chars.empty?
+
+        base_chars = UPPER_CHARS + LOWER_CHARS + NUMBER_CHARS
+        return base_chars if components.nil? || components.empty?
+
+        chars = []
+        if components.include?(:upper)
+          chars += UPPER_CHARS
+        end
+        if components.include?(:lower)
+          chars += LOWER_CHARS
+        end
+        if components.include?(:number)
+          chars += NUMBER_CHARS
+        end
+        chars.empty? ? base_chars : chars
+      end
+    end
+  end
+end
+
+

data/lib/tekido/version.rb

@@ -0,0 +1,4 @@
+# coding: utf-8
+module Tekido
+  VERSION = "1.0.0"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+# coding: utf-8
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require "coveralls"
+require "simplecov"
+SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+SimpleCov.start do
+  add_filter '/spec/'
+  add_filter '/bundle/'
+end
+require "tekido"
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+TRY_COUNT = 100000
+ACCIDENTAL_RATE = 0.01
+ACCIDENTAL_COUNT = TRY_COUNT * ACCIDENTAL_RATE
+
+def valid_count(percent)
+  TRY_COUNT / 100 * percent
+end
+
+def expected_count(range_size = nil)
+  total = range_size && TRY_COUNT > range_size ? range_size : TRY_COUNT
+  (total * 0.9).to_i
+end

data/spec/tekido/methods/array_spec.rb

@@ -0,0 +1,81 @@
+# coding: utf-8
+require "spec_helper"
+
+describe Tekido::Methods do
+  describe "array methods" do
+    describe ".list" do
+      context "when size is #{TRY_COUNT}, values are :one, :two, :three and :four" do
+        let(:list) { Tekido.list(TRY_COUNT, [:one, :two, :three, :four]) }
+        it "returns array" do
+          expect(list).to be_an(Array)
+        end
+        it "returned array size is #{TRY_COUNT}" do
+          expect(list.size).to eq TRY_COUNT
+        end
+        it "returned array includes about 25% :one" do
+          expect(list.count { |item| item == :one }).to be_within(valid_count(25)).of(ACCIDENTAL_COUNT)
+        end
+        it "returned array includes about 25% :two" do
+          expect(list.count { |item| item == :two }).to be_within(valid_count(25)).of(ACCIDENTAL_COUNT)
+        end
+        it "returned array includes about 25% :three" do
+          expect(list.count { |item| item == :three }).to be_within(valid_count(25)).of(ACCIDENTAL_COUNT)
+        end
+        it "returned array includes about 25% :four" do
+          expect(list.count { |item| item == :four }).to be_within(valid_count(25)).of(ACCIDENTAL_COUNT)
+        end
+      end
+      context "when size is #{TRY_COUNT}, values are defined with ratio (one: 11.1, two: 22.2, three: 33.3, four: 33.4)" do
+        let(:list) { Tekido.list(TRY_COUNT, one: 11.1, two: 22.2, three: 33.3, four: 33.4) }
+        it "returns array" do
+          expect(list).to be_an(Array)
+        end
+        it "returned array size is #{TRY_COUNT}" do
+          expect(list.size).to eq TRY_COUNT
+        end
+        it "returned array includes about 11.1% :one" do
+          expect(list.count { |item| item == :one }).to be_within(valid_count(11.1)).of(ACCIDENTAL_COUNT)
+        end
+        it "returned array includes about 22.2% :two" do
+          expect(list.count { |item| item == :two }).to be_within(valid_count(22.2)).of(ACCIDENTAL_COUNT)
+        end
+        it "returned array includes about 33.3% :three" do
+          expect(list.count { |item| item == :three }).to be_within(valid_count(33.3)).of(ACCIDENTAL_COUNT)
+        end
+        it "returned array includes about 33.4% :four" do
+          expect(list.count { |item| item == :four }).to be_within(valid_count(33.4)).of(ACCIDENTAL_COUNT)
+        end
+      end
+      context "when size is #{TRY_COUNT}, values are defined with ratio (one: 10, two: 20, three: 30)" do
+        let(:list) { Tekido.list(TRY_COUNT, one: 10, two: 20, three: 30) }
+        it "returns array" do
+          expect(list).to be_an(Array)
+        end
+        it "returned array size is #{TRY_COUNT}" do
+          expect(list.size).to eq TRY_COUNT
+        end
+        it "returned array includes about 10% :one" do
+          expect(list.count { |item| item == :one }).to be_within(valid_count(10)).of(ACCIDENTAL_COUNT)
+        end
+        it "returned array includes about 20% :two" do
+          expect(list.count { |item| item == :two }).to be_within(valid_count(20)).of(ACCIDENTAL_COUNT)
+        end
+        it "returned array includes about 30% :three" do
+          expect(list.count { |item| item == :three }).to be_within(valid_count(30)).of(ACCIDENTAL_COUNT)
+        end
+        it "returned array includes about 40% nil" do
+          expect(list.count { |item| item.nil? }).to be_within(valid_count(40)).of(ACCIDENTAL_COUNT)
+        end
+      end
+      context "when invalid value_defs " do
+        let(:list) { Tekido.list(TRY_COUNT, "aaaa") }
+        it "returns array" do
+          expect(list).to be_an(Array)
+        end
+        it "returned array is filled by nil" do
+          expect(list.any?).to eq false
+        end
+      end
+    end
+  end
+end

data/spec/tekido/methods/boolean_spec.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+require "spec_helper"
+
+describe Tekido::Methods do
+  describe "boolean methods"do
+    describe ".yes?" do
+      context "with no argument" do
+        it "returns true with a probability of about 50 percent" do
+          i = 0
+          TRY_COUNT.times do
+            i += 1 if Tekido.yes?
+          end
+          expect(i).to be_within(TRY_COUNT / 2).of(ACCIDENTAL_COUNT)
+        end
+      end
+      context "with integer argument" do
+        it "returns true with a probability of about given percent" do
+          i = 0
+          TRY_COUNT.times do
+            i += 1 if Tekido.yes?(80)
+          end
+          expect(i).to be_within(valid_count(80)).of(ACCIDENTAL_COUNT)
+        end
+      end
+      context "with invalid argument" do
+        it "bahaves in the same way of no argument" do
+          i = 0
+          TRY_COUNT.times do
+            i += 1 if Tekido.yes?("99")
+          end
+          expect(i).to be_within(TRY_COUNT / 2).of(ACCIDENTAL_COUNT)
+        end
+      end
+    end
+  end
+end

data/spec/tekido/methods/date_spec.rb

@@ -0,0 +1,131 @@
+# coding: utf-8
+require "spec_helper"
+require "date"
+
+describe Tekido::Methods do
+  describe "date methods" do
+    describe ".date" do
+      context "with no argument" do
+        it "returns Date" do
+          expect(Tekido.date).to be_a(Date)
+        end
+        it "at random uniformly" do
+          min, max = Date.new(1, 1, 1), Date.new(9999, 12, 31)
+          list = TRY_COUNT.times.map { Tekido.date }
+          expect(list.uniq.size).to be >= expected_count(max - min)
+        end
+      end
+      context "with integer argument" do
+        let(:date) { Tekido.date(1999) }
+        it "returns Date" do
+          expect(date).to be_a(Date)
+        end
+        it "at random uniformly" do
+          min, max = Date.new(1999, 1, 1), Date.new(1999, 12, 31)
+          list = TRY_COUNT.times.map { Tekido.date(1999) }
+          expect(list.uniq.size).to be >= expected_count(max - min)
+        end
+        it "returned Date's year is 1999" do
+          expect(date.year).to eq 1999
+        end
+      end
+      context "with integer range argument" do
+        it "returns Date" do
+          expect(Tekido.date(1999..2010)).to be_a(Date)
+        end
+        it "at random uniformly" do
+          min, max = Date.new(1999, 1, 1), Date.new(2010, 12, 31)
+          list = TRY_COUNT.times.map { Tekido.date(1999..2010) }
+          expect(list.uniq.size).to be >= expected_count(max - min)
+        end
+        it "returned Date's year is included in argument" do
+          TRY_COUNT.times do
+            expect(1999..2010).to include(Tekido.date(1999..2010).year)
+          end
+        end
+      end
+      context "with Date range argument" do
+        let(:min) { Date.new(1999, 2, 21) }
+        let(:max) { Date.new(2013, 10, 11)}
+        it "returns Date" do
+          expect(Tekido.date(min..max)).to be_a(Date)
+        end
+        it "at random uniformly" do
+          list = TRY_COUNT.times.map { Tekido.date(min..max) }
+          expect(list.uniq.size).to be >= expected_count(max - min)
+        end
+        it "returned Date is included in argument" do
+          TRY_COUNT.times do
+            expect(min..max).to cover(Tekido.date(min..max))
+          end
+        end
+      end
+      context "with invalid argument" do
+        it "returns nil" do
+          expect(Tekido.date("2010")).to be_nil
+        end
+      end
+    end
+    describe ".birthday" do
+      context "with no argument" do
+        it "returns Date" do
+          expect(Tekido.birthday).to be_a(Date)
+        end
+        it "at random uniformly" do
+          min = (Date.today << 12 * 101) + 1
+          list = TRY_COUNT.times.map { Tekido.birthday }
+          expect(list.uniq.size).to be >= expected_count(Date.today - min)
+        end
+        it "returned Date satisfy that current age is more than 0 and less than 100" do
+          min = (Date.today << 12 * 101) + 1
+          TRY_COUNT.times do
+            expect(min..Date.today).to cover(Tekido.birthday)
+          end
+        end
+      end
+      context "with integer argument" do
+        let(:age) { 28 }
+        it "returns Date" do
+          expect(Tekido.birthday(age)).to be_a(Date)
+        end
+        it "at random uniformly" do
+          min = (Date.today << 12 * (age + 1)) + 1
+          max = Date.today << 12 * age
+          list = TRY_COUNT.times.map { Tekido.birthday }
+          expect(list.uniq.size).to be >= expected_count(max - min)
+        end
+        it "given integer is age" do
+          min = (Date.today << 12 * (age + 1)) + 1
+          max = Date.today << 12 * age
+          TRY_COUNT.times do
+            expect(min..max).to cover(Tekido.birthday(age))
+          end
+        end
+      end
+      context "with integer range argument" do
+        it "returns Date" do
+          expect(Tekido.birthday(20..25)).to be_a(Date)
+        end
+        it "at random uniformly" do
+          min = (Date.today << 12 * 26) + 1
+          max = Date.today << 12 * 20
+          list = TRY_COUNT.times.map { Tekido.birthday }
+          expect(list.uniq.size).to be >= expected_count(max - min)
+        end
+        it "returned Date satisfy that current age is included in argument" do
+          min = (Date.today << 12 * 26) + 1
+          max = Date.today << 12 * 20
+          TRY_COUNT.times do
+            expect(min..max).to cover(Tekido.birthday(20..25))
+          end
+        end
+      end
+      context "with invalid argument" do
+        it "returns nil" do
+          expect(Tekido.birthday("30")).to be_nil
+        end
+      end
+    end
+  end
+end
+