random_fu 0.0.3

data/.gitignore

@@ -0,0 +1,2 @@
+**.swp
+tags

data/MIT-LICENSE

@@ -0,0 +1,23 @@
+LICENSE
+
+The MIT License
+
+Copyright (c) 2012 Ledsworth Consulting LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,66 @@
+Random_fu 
+=========
+
+A Ruby gem to add random capability.  Currently, only for Strings.  
+
+DO NOT USE for generating any data related to security!!!  
+---------------------------------------------------------
+There are better, more secure, methods for this.  This gem is meant ONLY for non secure
+random strings.
+
+Installation
+============
+
+Random_fu will soon be distributed as a ruby gem (not yet published, in dev).  Simply require it in your Gemfile.
+
+    gem "random_fu"
+
+## Usage
+
+## String#random_order
+
+Returns a random string created from the characters in the string.  Characters in the string are used only once, and the result
+will be the same length.  The result is simply a jumbled version.
+
+### Examples:
+
+    "abc".random_order
+    # => "cba"
+    
+    "abcdef".random_order[0]    # Random letter between a and f
+    # => "b"
+
+    "abcdef".random_order[0,2]  # Two random letters between a and f
+    # => "eb"
+
+## String#random(count)
+
+Returns a random string the size of count created from the characters in the string.  Characters are used one or more times, and
+characters may repeat and/or not be used at all.  The source string is just a list of possible characters (to place a 
+string in a random order, use String#random_order).  For example, "abcd".random(n) could result in 
+just one letter used multiple times:
+
+     "abcd".random(2)
+     # => "dd"
+
+### Examples:
+
+To produce a random character from the alphabet:
+
+    "abcdefghijklmnopqrstuvwxyz".random(1)
+    # => "d"
+
+    ("a".."z").to_a.join.random(1)
+    # => "j"
+
+To produce a 20 character random string from the alphabet:
+
+    "abcdefghijklmnopqrstuvwxyz".random(20)
+    # => "ijvrvddrwgucdsyzybfq"
+
+
+License
+=======
+
+random_fu is Copyright © 2012 Ledsworth Consulting LLC.  It is free software, and may be 
+redistributed under the terms specified in the MIT-LICENSE file. 

data/lib/random_fu/string.rb

@@ -0,0 +1,47 @@
+# Top level module for random_fu
+# 
+# Author:: Brian Ledsworth of Ledsworth Consluting LLC
+# Copyright:: Copyright (c) 2012 Ledsworth Consulting LLC. 
+# License:: MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+module RandomFu
+
+  # Instance methods mixed into String
+  module StringInstanceMethods
+
+    # Returns a random string the size of count created from the characters in 
+    # the string.  Characters are used one or more times, and characters may 
+    # repeat and/or not be used at all.  The source string is just a list of 
+    # possible characters (to place a string in a random order, use 
+    # String#random_order).  For example, "abcd".random(n) could result in 
+    # just one letter used multiple times:
+    def random(count)
+      if !count.is_a?(Integer) || count < 1 then 
+        raise(ArgumentError, "count needs to be a Integer >= 1") 
+      end
+      return "" if self.empty?
+
+      result = ""
+      1.upto(count) do
+        result << self[rand(self.length)]
+      end
+      result
+    end
+
+    # Returns a random string created from the characters in the string.  
+    # Characters in the string are used only once, and the result
+    # will be the same length.  The result is simply a jumbled version.
+    def random_order
+      return "" if self.empty?
+
+      result = ""
+      chars = self.split(//)
+      1.upto(chars.size) do
+        result << chars.delete_at(rand(chars.size))
+      end
+      result
+    end
+
+  end
+
+end

data/lib/random_fu/version.rb

@@ -0,0 +1,3 @@
+module RandomFu
+  VERSION = '0.0.3'
+end

data/lib/random_fu.rb

@@ -0,0 +1,4 @@
+require_relative 'random_fu/version'
+require_relative 'random_fu/string'
+
+String.send :include, RandomFu::StringInstanceMethods

data/random_fu.gemspec

@@ -0,0 +1,19 @@
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+require 'random_fu/version.rb'
+
+Gem::Specification.new do |s|
+  s.name = "random_fu"
+  s.summary = "Random helpers"
+  s.version = RandomFu::VERSION
+  s.author = "Brian Ledsworth of Ledsworth Consluting LLC"
+  s.description = "Incorprate random helpers into your app"
+  s.email = ["brian@ledsworth.com"]
+  s.homepage = "https://github.com/AgileMantis/random_fu"
+  s.required_ruby_version = '>= 1.9.3'
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+  # s.has_rdoc = false
+  # s.add_development_dependency('rspec')
+  # s.platform = Gem::Platform::RUBY
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../lib/random_fu.rb'

data/spec/string_random_order_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe "random_fu's String#random_order" do
+    
+  let(:string) { "abcdefghijklmnopqrstuvwxyz0123456789" }
+
+  describe "when called on an empy string" do
+    it "should return an empty string" do
+      "".random_order.should == ""
+      # I can't see this as a valid use case, but don't feel
+      # it should throw an error.  So I left it awaiting
+      # community feedback.
+    end
+  end
+
+  describe "when called on a single char string" do
+    it "should return same string" do
+      "f".random_order.should == "f"
+      # I can't see this as a valid use case, but don't feel
+      # it should throw an error.  So I left it awaiting
+      # community feedback.
+    end
+  end
+
+  describe "should return a random string which" do
+
+    it "should be the same length" do
+      string.random_order.should_not == string 
+    end
+
+    it "should contain the exact same characters but jumbled" do
+      rand = string.random_order
+      rand.length.should == string.length
+      rand_set = rand.split(//) - string.split(//)
+      rand_set.should be_empty, rand_set
+    end
+
+  end
+
+end

data/spec/string_random_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe "random_fu's String#random" do
+    
+  let(:string) { "abcdefghijklmnopqrstuvwxyz0123456789" }
+
+  describe "when called incorrectly" do
+
+    describe "with no arguments" do
+      it "should raise an ArgumentError" do
+        lambda { rand = string.random }.should raise_exception(ArgumentError)
+      end
+    end
+
+    describe "with a non Integer" do
+      it "should raise an ArgumentError" do
+        lambda { rand = string.random("foo")  }.should raise_exception(ArgumentError)
+        lambda { rand = string.random(-1)  }.should raise_exception(ArgumentError)
+        lambda { rand = string.random(0)  }.should raise_exception(ArgumentError)
+      end
+    end
+
+    describe "on a empty" do
+      it "should return a blank string" do
+        "".random(100).should == ""
+      end
+    end
+
+    describe "on a single char string" do
+      it "should return a sting made up of just that char" do
+        "f".random(30).should == "f"*30
+        # I can't see this as a valid use case, but don't feel
+        # it should throw an error.  So I left it awaiting
+        # community feedback.
+      end
+    end
+
+  end
+
+  describe "should return a random string which" do
+
+    it "should be created only from the characters of the String" do
+      rand = string.random(string.length)
+      rand.should_not == string
+      # Cant simply set theory, as rand may not contain all chars 
+      # from string (e.g. "abcd".random might return "cabc")
+      (string.split(//) & rand.split(//)).each do |odd_char|
+        string.should include(odd_char)
+      end
+    end
+
+    it "should be the same length as the argument" do
+      [ 1, 5, string.length, string.length*2 ].each do |arg|
+        string.random(arg).length.should == arg
+      end
+    end
+
+  end
+
+end
+
+
+
+
+# 
+# 
+# 
+# 
+# 
+#     it "should return a random string of the same length" do
+#       rand = string.random
+#       rand.length.should == string.length
+#       rand.should_not == string
+#       rand.chars.each do |char|
+#         string.should include(char)
+#       end
+#     end
+#     
+#     it "should not use an index greater than its length" do
+#       string = "ab"
+#       1.upto(99) do
+#         string.random.length.should == string.length 
+#         # nil returned from String#[index to high] would not increase
+#         # the length of the result string after foo.join.  Thus, if  
+#         # random went out of bounds on index, the result string 
+#         # would be less in size.
+#       end
+#     end
+#   
+#   end
+# 
+#   describe "with argument of 0" do
+# 
+#     it "should return a blank string" do
+#       rand = string.random(0)
+#       rand.should == ""
+#     end
+# 
+#   end
+# 
+#   describe "with invalid arguments" do
+# 
+#     it "should raise an exception when count is too high" do
+#       lambda { rand = string.random(string.length+1) }.should raise_exception
+#     end
+# 
+#     it "should raise an exception if it's negative" do
+#       lambda { rand = string.random(-1) }.should raise_exception
+#     end
+# 
+#     it "should raise an exception if not an Integer class" do
+#       lambda { rand = string.random("foo") }.should raise_exception
+#       lambda { rand = string.random(0.1) }.should raise_exception
+#     end
+# 
+#   end
+#  
+

data/spec/version_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe "random_fu's version" do
+  it "should be current" do
+    RandomFu::VERSION.should == '0.0.3'
+  end
+end
+

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: random_fu
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Brian Ledsworth of Ledsworth Consluting LLC
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-20 00:00:00 Z
+dependencies: []
+
+description: Incorprate random helpers into your app
+email: 
+- brian@ledsworth.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- MIT-LICENSE
+- README.md
+- lib/random_fu.rb
+- lib/random_fu/string.rb
+- lib/random_fu/version.rb
+- random_fu-0.0.2.gem
+- random_fu-0.0.3.gem
+- random_fu.gemspec
+- spec/spec_helper.rb
+- spec/string_random_order_spec.rb
+- spec/string_random_spec.rb
+- spec/version_spec.rb
+homepage: https://github.com/AgileMantis/random_fu
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Random helpers
+test_files: 
+- spec/spec_helper.rb
+- spec/string_random_order_spec.rb
+- spec/string_random_spec.rb
+- spec/version_spec.rb
+has_rdoc: