web-utils 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 406c990b91a61d30f76d4ff065013eaf1ec741ea
+  data.tar.gz: 4788cfe256f7e536de8067c79bef7193a35ed0e7
+SHA512:
+  metadata.gz: 2a675233f99d1b6b7299e830c6d80fbf46637b2d9c43c1a35753887ec1f254b126f4e0cfcb439d080a1c11eb80bd527f0807c4030f352365d44644b23ddea476
+  data.tar.gz: 08f910f903304d445e32a66f20ad8bb9c025d6b5516f4437b83ae8f18654d0633d9c05b40275033b2cd2b451fc636ab41a0496e8ae978e4215fe86d69d18edb4

data/.gitignore

@@ -0,0 +1,7 @@
+.DS_STORE
+*.swp
+*.sass-cache
+pkg/
+Gemfile.lock
+.bundle/
+

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+gemspec
+gem 'minitest', '>=5.8.0'
+

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2016 Mickael Riga
+
+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,242 @@
+WebUtils
+========
+
+`WebUtils` is basically a collection of useful helper 
+methods that are quite common to have in a web project.
+It is organized like `Rack::Utils` and actually extends it.
+
+Some of the methods are similar to methods you would have 
+in `Active::Support` but without monkey patching. Although it
+is only a coincidence. The purpose is not to build an alternative.
+
+Here is how you would use it with `Sinatra`:
+
+```ruby
+require 'sinatra/base'
+require 'web_utils'
+
+class Main < Sinatra::Base
+
+  # Your frontend code...
+
+  helpers do
+    include WebUtils
+    # Your other helpers...
+  end
+
+end
+```
+
+Some methods are also useful on the model side.
+
+Here is a list of the available methods and what they do:
+
+`blank?(string)`
+----------------
+
+Just tells you if the string is blank or not.
+
+`pluralize(string)`
+-------------------
+
+Pluralize simple words. Just override when necessary.
+
+`singularize(string)`
+-------------------
+
+Singularize simple words. Just override when necessary.
+
+`dasherize_class_name(string)`
+------------------------------
+
+Dasherize class names. Module separator is a double dash. 
+So `BlogArticle::Comment` becomes `blog-article--comment`. 
+Also for simplicity, it does not gather accronyms. e.g. `net--f-t-p`.
+This is useful for urls or creating CSS class names or IDs.
+
+`undasherize_class_name(string)`
+--------------------------------
+
+Basically the opposite.
+
+`resolve_class_name(string, context=Kernel)`
+--------------------------------------------
+
+It takes the class name as a string and returns the class.
+You can pass a class name with modules as well (e.g. "Net::FTP").
+This is actually the main reason why there is a `context`
+argument, because it uses recursion to do this.
+But `context` is still useful otherwise.
+
+`resolve_dasherized_class_name(string)`
+---------------------------------------
+
+Same except that it takes the dasherized version of the 
+class name as an argument and returns the class itself (not a string).
+Useful for resolving a class from a URL param.
+
+`guess_related_class_name(parent_class, string)`
+------------------------------------------------
+
+It is mainly used for guessing the class name of a 
+children class with a plural name. 
+So `guess_related_class_name(BlogArticle, :comments)` 
+will return `'BlogArticle::Comment'`.
+
+`get_value(value, target=Kernel)`
+----------------------------------
+
+It is used for example for getting a default value for something
+and it is passed either as:
+
+- A direct value (e.g. `"John Doe"`)
+- A proc (e.g. `proc{ Time.now }`)
+- A symbol (e.g. `:get_last_value`)
+
+In the case of a symbol, the message is called on the target.
+Therefore you would always give the target just in case it
+is a symbol.
+
+If the value can only be direct or a Proc, you can ignore the
+second argument (target).
+
+`deep_copy(object)`
+-------------------
+
+This makes a deeper copy of an object, since `dup` does not 
+duplicate nested objects in a hash for example. It uses a simple 
+marshal/unmarshal mechanism. 
+
+It is a bit of a hack and not that web-specific, but useful
+if you want to avoid some nasty bugs.
+
+`ensure_key!(hash, key, default_value)`
+---------------------------------------
+
+If the hash does not have the key, it sets it with the 
+default value. And this value is also returned by the method.
+
+`ensure_key(hash, key, default_value)`
+--------------------------------------
+
+Same as `ensure_key!` except that it does not change the original
+hash. It returns a new one.
+
+`slugify(string, force_lowercase=true)`
+-----------------
+
+This makes the strings ready to be used as a slug in a URL. 
+It removes the accents, replaces a lot of separators with 
+dashes and escapes it. By default it forces the output to 
+be lowercase, but if you pass `false` as a second argument, 
+it will not change the case of letters.
+
+`label_for_field(string_or_symbol)`
+-----------------------------------
+
+Returns a human readable version of a field name.
+It says `field`, but it could be any kind of symbol I guess.
+
+`each_stub(nested_object) {|object,key_or_index,value| ... }`
+-------------------------------------------------------------
+
+It is used to run something on all the nested stubs of 
+an array or a hash. The second argument of the block is 
+either a key if the object is a hash, or an index if the 
+object is an array.
+
+`automatic_typecast(string, casted=[:bool, :nil, :int, :float])`
+----------------------------
+
+It tries to change a string value received by an HTML form 
+or a CSV file into an object when it can. So far it recognizes 
+simple things like `true`, `false`, integers and floats. 
+And an empty string is always `nil`.
+
+The second argument is the list of things you want to typecast.
+By default there is everything, but you only want to typecast
+integers and floats, you can pass `[:int, :float]`.
+
+`generate_random_id(size)` 
+--------------------------
+
+Like the name suggests, it generates a random string of 
+only letters and numbers. If you  don't provide a size, 
+it defaults to 16.
+
+`nl2br(string, br="<br>")` 
+--------------------------
+
+The classic `nl2br` which makes sure return lines are 
+turned into `<br>` tags. You can use the second argument if 
+you want to specify what the replacement tag should be. 
+Just in case you want self-closing tags. 
+
+`complete_link(string)`
+-----------------------
+
+This just makes sure that a link is complete. Very often 
+people tend to enter a URL like `www.google.com` which is a 
+controversial `href` for some browsers, so it changes it to 
+`//www.google.com`. Already seemingly complete links are not
+affected by the method.
+
+`external_link?(string)` 
+------------------------
+
+This tells you if a link is pointing to the current site or 
+an external one. This is useful when you want to create a link 
+tag and want to decide if target is `'_blank'` or `'_self'`.
+
+`automatic_html(string, br="<br>")`
+-----------------------------------
+
+This automatically does `nl2br` and links recognizable things 
+like email addresses and URLs. Not as good as markdown, but it 
+is quite useful, should it be only for turning an email into a link.
+
+`truncate(string, size=320, ellipsis="...")` 
+--------------------------------------------
+
+It truncates a string like what you have in blog summaries. 
+It automatically removes tags and line breaks. The length is 
+320 by default. When the original string was longer, it puts 
+an ellipsis at the end which can be replaced by whatever you put 
+as a 3rd argument. e.g. `'...and more'`.
+
+`display_price(int)` 
+--------------------
+
+It changes a price in cents/pence into a formated string 
+like `49,425.40` when you pass `4942540`.
+
+`parse_price(string)`
+---------------------
+
+It does the opposite of `display_price` and parses a string in 
+order to return a price in cents/pence.
+
+`branded_filename(path, brand="WebUtils")`
+------------------------------------------
+
+It takes the path to a file and add the brand/prefix and a dash 
+before the file name (really the file name, not the path). 
+By default, the brand/prefix is `WebUtils`.
+
+`filename_variation(path, variation, ext)`
+------------------------------------------
+
+For example you have a file `/path/to/image.jpg` and you want 
+to create its `thumbnail` in `png`, you can create the thumnail 
+path with `filename_variation(path, :thumbnail, :png)` and it 
+will return `/path/to/image.thumbnail.png`.
+
+`initial_request?(request)`
+---------------------------
+
+You basically pass the `Request` object to the method and it
+looks at the referrer and returns true if it was not on the same
+domain. Essentially tells you if the visitor just arrived.
+
+
+

data/lib/web_utils.rb

@@ -0,0 +1,232 @@
+# encoding: utf-8
+
+require 'rack/utils'
+require 'uri'
+
+module WebUtils
+
+  # Most methods are supposed to be as simple as possible
+  # and just cover most cases.
+  # I would rather override specific cases rather than making
+  # complicated methods.
+
+  extend Rack::Utils
+
+  def blank? s
+    s.to_s.strip==''
+  end
+  module_function :blank?
+
+  def pluralize s
+    s<<'e' if s[-1,1]=='x'
+    s<<'s'
+    s.sub(/([b-df-hj-np-tv-z])ys$/,'\1ies')
+  end
+  module_function :pluralize
+
+  def singularize s
+    case s
+    when /xes$/
+      s[0..-3]
+    when /ies$/
+      s.sub(/ies$/, 'y')
+    when /s$/
+      s[0..-2]
+    else
+      s
+    end
+  end
+  module_function :singularize
+
+  def dasherize_class_name s
+    s.gsub(/([A-Z]|\d+)/){|str|"-#{str.downcase}"}[1..-1].gsub('::','-')
+  end
+  module_function :dasherize_class_name
+
+  def undasherize_class_name s
+    s.capitalize.gsub(/\-([a-z0-9])/){|str|$1.upcase}.gsub('-','::')
+  end
+  module_function :undasherize_class_name
+
+  def resolve_class_name s, context=Kernel
+    current, *payload = s.to_s.split('::')
+    raise(NameError) if current.nil?
+    const = context.const_get(current)
+    if payload.empty?
+      const
+    else
+      resolve_class_name(payload.join('::'),const)
+    end
+  end
+  module_function :resolve_class_name
+
+  def resolve_dasherized_class_name s
+    resolve_class_name(undasherize_class_name(s.to_s)) 
+  end
+  module_function :resolve_dasherized_class_name
+
+  def guess_related_class_name context, clue
+    context.respond_to?(:name) ? context.name : context.to_s
+    clue = clue.to_s
+    return clue if clue=~/^[A-Z]/
+    if clue=~/^[a-z]/
+      clue = undasherize_class_name singularize(clue).gsub('_','-')
+      clue = "::#{clue}"
+    end
+    "#{context}#{clue}"
+  end
+  module_function :guess_related_class_name
+
+  def get_value raw, context=Kernel
+    if raw.is_a? Proc
+      raw.call
+    elsif raw.is_a? Symbol
+      context.__send__ raw
+    else
+      raw
+    end
+  end
+  module_function :get_value
+
+  def deep_copy original
+    Marshal.load(Marshal.dump(original))
+  end
+  module_function :deep_copy
+
+  def ensure_key! h, k, v
+    h[k] = v unless h.key?(k)
+    h[k]
+  end
+  module_function :ensure_key!
+
+  def ensure_key h, k, v
+    new_h = h.dup
+    self.ensure_key! new_h, k, v
+    new_h
+  end
+  module_function :ensure_key
+
+  ACCENTS_FROM = 
+    "ÀÁÂÃÄÅàáâãäåĀāĂ㥹ÇçĆćĈĉĊċČčÐðĎďĐđÈÉÊËèéêëĒēĔĕĖėĘęĚěĜĝĞğĠġĢģĤĥĦħÌÍÎÏìíîïĨĩĪīĬĭĮįİıĴĵĶķĸĹĺĻļĽľĿŀŁłÑñŃńŅņŇňʼnŊŋÒÓÔÕÖØòóôõöøŌōŎŏŐőŔŕŖŗŘřŚśŜŝŞ"
+  ACCENTS_TO = 
+    "AAAAAAaaaaaaAaAaAaCcCcCcCcCcDdDdDdEEEEeeeeEeEeEeEeEeGgGgGgGgHhHhIIIIiiiiIiIiIiIiIiJjKkkLlLlLlLlLlNnNnNnNnnNnOOOOOOooooooOoOoOoRrRrRrSsSsSsSssT"
+  def slugify s, force_lower=true
+    s = s.to_s.tr(ACCENTS_FROM,ACCENTS_TO).tr(' .,;:?!/\'"()[]{}<>','-').gsub(/&/, 'and').gsub(/-+/,'-').gsub(/(^-|-$)/,'')
+    s = s.downcase if force_lower
+    escape(s)
+  end
+  module_function :slugify
+
+  def label_for_field field_name
+    field_name.to_s.scan(/[a-zA-Z0-9]+/).map(&:capitalize).join(' ')
+  end
+  module_function :label_for_field
+
+  def each_stub obj, &block 
+    raise TypeError, 'WebUtils.each_stub expects an object which respond to each_with_index' unless obj.respond_to?(:each_with_index)
+    obj.each_with_index do |(k,v),i|
+      value = v || k
+      if value.is_a?(Hash) || value.is_a?(Array)
+        each_stub(value,&block)
+      else
+        block.call(obj, (v.nil? ? i : k), value)
+      end
+    end
+  end
+  module_function :each_stub
+
+  def automatic_typecast str, casted=[:bool,:nil,:int,:float] 
+    return str unless str.is_a?(String)
+    if casted.include?(:bool) and str=='true'
+      true
+    elsif casted.include?(:bool) and str=='false'
+      false
+    elsif casted.include?(:nil) and str==''
+      nil
+    elsif casted.include?(:int) and str=~/^-?\d+$/
+      str.to_i
+    elsif casted.include?(:float) and str=~/^-?\d*\.\d+$/
+      str.to_f
+    else
+      str
+    end
+  end
+  module_function :automatic_typecast
+
+  ID_CHARS = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a
+  ID_SIZE = 16
+  def generate_random_id size=ID_SIZE
+    id = ''
+    size.times{id << ID_CHARS[rand(ID_CHARS.size)]} 
+    id
+  end
+  module_function :generate_random_id
+
+  def nl2br s, br='<br>'
+    s.to_s.gsub(/\n/,br)
+  end
+  module_function :nl2br
+
+  def complete_link link
+    if blank?(link) or link=~/^(\/|[a-z]*:)/
+      link
+    else
+      "//#{link}"
+    end
+  end
+  module_function :complete_link
+
+  def external_link? link
+    !!(link =~ /^[a-z]*:?\/\//)
+  end
+  module_function :external_link?
+
+  def automatic_html s, br='<br>'
+    replaced = s.to_s.
+    gsub(/\b((https?:\/\/|ftps?:\/\/|www\.)([A-Za-z0-9\-_=%&@\?\.\/]+))\b/) do |str|
+      url = complete_link $1
+      "<a href='#{url}' target='_blank'>#{$1}</a>"
+    end.
+    gsub(/([^\s]+@[^\s]*[a-zA-Z])/) do |str|
+      "<a href='mailto:#{$1.downcase}'>#{$1}</a>"
+    end
+    nl2br(replaced,br).gsub("@", "&#64;")
+  end
+  module_function :automatic_html
+
+  def truncate s,c=320,ellipsis='...'
+    s.to_s.gsub(/<[^>]*>/, '').gsub(/\n/, ' ').sub(/^(.{#{c}}\w*).*$/m, '\1'+ellipsis)
+  end
+  module_function :truncate
+
+  def display_price int
+    raise(TypeError, 'The price needs to be the price in cents/pence as an integer') unless int.is_a?(Integer)
+    ("%.2f" % (int/100.0)).sub(/\.00/, '').reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+  end
+  module_function :display_price
+
+  def parse_price string
+    raise(TypeError, 'The price needs to be parsed from a String') unless string.is_a?(String)
+    ("%.2f" % string.gsub(/[^\d\.\-]/, '')).gsub(/\./,'').to_i
+  end
+  module_function :parse_price
+
+  def branded_filename path, brand='WebUtils'
+    "#{File.dirname(path)}/#{brand}-#{File.basename(path)}".sub(/^\.\//,'')
+  end
+  module_function :branded_filename
+
+  def filename_variation path, variation, ext
+    old_ext = File.extname(path) 
+    path.sub(/#{Regexp.escape old_ext}$/, ".#{variation}.#{ext}")
+  end
+  module_function :filename_variation
+
+  def initial_request? request
+    return true unless request.referer=~URI.regexp
+    URI.parse(request.referer).host!=request.host
+  end
+  module_function :initial_request?
+
+end
+

data/test/test_web_utils.rb

@@ -0,0 +1,524 @@
+require 'minitest/autorun'
+require 'web_utils'
+
+require 'rack/request'
+require 'rack/mock'
+
+module FakeModule
+  module FakeSubModule
+  end
+end
+
+describe WebUtils do
+
+  parallelize_me!
+
+  let(:utils) { WebUtils }
+
+  describe '#blank?' do
+    describe 'with blank strings' do
+      it 'is true' do
+        ['',' '," \n \t"].each do |s|
+          assert utils.blank?(s)
+        end
+      end
+    end
+    describe 'with nil' do
+      it('is true') { assert utils.blank?(nil) }
+    end
+    describe 'with non-blank strings' do
+      it 'is false' do
+        ['a','abc', '  abc  '].each do |s|
+          refute utils.blank?(s)
+        end
+      end
+    end
+    describe 'with integer' do
+      it('is false') { refute utils.blank?(1234) }
+    end
+  end
+
+  describe '#pluralize' do
+
+    it "Just adds an 's' at the end" do
+      assert_equal 'bags', utils.pluralize('bag')
+      assert_equal 'days', utils.pluralize('day')
+    end
+    describe "The word ends with 'x'" do
+      it "Adds 'es' instead" do
+        assert_equal 'foxes', utils.pluralize('fox')
+      end
+    end
+    describe "The word ends with a consonant and 'y'" do
+      it "Replaces 'y' with 'ie'" do
+        assert_equal 'copies', utils.pluralize('copy')
+      end
+    end
+
+  end
+
+  describe '#singularize' do
+
+    it "Removes the trailing 's'" do
+      assert_equal 'bag', utils.singularize('bags')
+    end
+    describe "The word ends with 'xes'" do
+      it "Removes the 'e' as well" do
+        assert_equal 'fox', utils.singularize('foxes')
+      end
+    end
+    describe "The word ends with 'ies'" do
+      it "Replaces 'ie' with 'y'" do
+        assert_equal 'copy', utils.singularize('copies')
+      end
+    end
+
+  end
+
+  describe 'dasherize/undasherize class name' do
+
+    let(:cases) {
+      [
+        ['Hello','hello'],
+        ['HelloWorld','hello-world'],
+        ['HTTPRequest','h-t-t-p-request'],
+        ['RestAPI','rest-a-p-i'],
+        ['AlteredSMTPAttachment','altered-s-m-t-p-attachment'],
+        ['View360', 'view-360'],
+        ['View360Degree', 'view-360-degree'],
+        ['Degree360::View', 'degree-360--view'],
+        ['RestAPI::Request::Post','rest-a-p-i--request--post'],
+      ]
+    }
+
+    describe '#dasherize_class_name' do
+      it "Translates correctly" do
+        cases.each do |(classname,dashname)|
+          assert_equal dashname, utils.dasherize_class_name(classname)
+        end
+      end
+    end
+
+    describe '#undasherize_class_name' do
+      it "Translates correctly" do
+        cases.each do |(classname,dashname)|
+          assert_equal classname, utils.undasherize_class_name(dashname)
+        end
+      end
+    end
+
+  end
+
+  describe '#resolve_class_name' do
+    describe 'when the constant exists' do
+      it 'Returns the constant' do
+        [
+          ['String',String],
+          ['FakeModule::FakeSubModule',FakeModule::FakeSubModule],
+        ].each do |(classname,constant)|
+          assert_equal constant, utils.resolve_class_name(classname)
+        end
+      end
+    end
+    describe 'when the constant does not exist' do
+      it 'Raise if the constant does not exist' do
+        ['Strang','WebUtils::Yootils','',nil].each do |classname|
+          assert_raises(NameError) do
+            utils.resolve_class_name(classname)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#resolve_dasherized_class_name' do
+    it 'Chains both methods for sugar' do
+      assert_equal FakeModule::FakeSubModule, utils.resolve_dasherized_class_name('fake-module--fake-sub-module')
+      assert_equal FakeModule::FakeSubModule, utils.resolve_dasherized_class_name(:'fake-module--fake-sub-module')
+    end
+  end
+
+  describe '#guess_related_class_name' do
+  
+    # Used for many things but mainly relationship classes
+
+    describe 'when it starts with a lowercase letter' do
+      it 'Should guess a singular class_name in the context' do
+        assert_equal 'FakeModule::FakeSubModule::RelatedThing', utils.guess_related_class_name(FakeModule::FakeSubModule, :related_things)
+        assert_equal 'FakeModule::FakeSubModule::RelatedThing', utils.guess_related_class_name(FakeModule::FakeSubModule, :related_thing)
+      end
+    end
+    describe 'when it starts with an uppercase letter' do
+      it 'Should return the class_name as-is' do
+        assert_equal 'Class::Given', utils.guess_related_class_name(FakeModule::FakeSubModule, 'Class::Given')
+      end
+    end
+    describe 'when it starts with ::' do
+      it 'Should prepend the class_name whith the context' do
+        assert_equal 'FakeModule::FakeSubModule::RelatedThing', utils.guess_related_class_name(FakeModule::FakeSubModule, '::RelatedThing')
+      end
+    end
+  end
+
+  describe '#get_value' do
+    describe 'when arg is a simple object' do
+      it 'Returns it as-is' do
+        assert_equal 'Hello', utils.get_value('Hello')
+      end
+    end
+    describe 'when arg is a proc' do
+      it 'Returns after calling the proc' do
+        assert_equal 'Hello', utils.get_value(proc{'Hello'})
+      end
+    end
+    describe 'when arg is a lambda' do
+      it 'Returns after calling the lambda' do
+        assert_equal 'Hello', utils.get_value(lambda{'Hello'})
+      end
+    end
+    describe 'when arg is a symbol' do
+      describe 'and a context is passed as a second argument' do
+        it 'Sends the message to the context' do
+          assert_equal 'Hello', utils.get_value(:capitalize,'hello')
+        end
+      end
+      describe 'and no context is passed' do
+        it 'Sends the message to Kernel' do
+          assert_equal 'Kernel', utils.get_value(:to_s)
+        end
+      end
+    end
+  end
+
+  describe '#deep_copy' do
+    it 'Duplicates the nested objects' do
+      original = {nested_hash: {one: 1}, nested_array: [1]}
+      copy = utils.deep_copy(original)
+      copy[:nested_hash][:one] = 2
+      copy[:nested_array] << 2
+      assert_equal({one: 1}, original[:nested_hash])
+      assert_equal [1], original[:nested_array]
+    end
+  end
+
+  describe '#ensure_key!' do
+    let(:arg) { {a: 3} }
+    it 'Sets the key if it did not exist' do
+      utils.ensure_key!(arg,:b,4)
+      assert_equal 4, arg[:b]
+    end
+    it 'Leaves the key untouched if it already existed' do
+      utils.ensure_key!(arg,:a,4)
+      assert_equal 3, arg[:a]
+    end
+    it 'Returns the value of the key' do
+      assert_equal 4, utils.ensure_key!(arg,:b,4)
+      assert_equal 3, utils.ensure_key!(arg,:a,4)
+    end
+  end
+
+  describe '#ensure_key' do
+    let(:arg) { {a: 3} }
+    it 'Does not change the original' do
+      new_hash = utils.ensure_key(arg,:b,4)
+      refute_equal 4, arg[:b]
+      assert_equal 4, new_hash[:b]
+    end
+  end
+
+  describe '#slugify' do
+
+    # For making slug for a document
+    # Possibly used instead of the id
+
+    let(:arg) { "Así es la vida by Daniel Bär & Mickaël ? (100%)" }
+    it 'Builds a string made of lowercase URL-friendly chars' do
+      assert_equal 'asi-es-la-vida-by-daniel-bar-and-mickael-100%25', utils.slugify(arg)
+    end
+    describe 'when second argument is false' do
+      it 'Does not force to lowercase' do
+        assert_equal 'Asi-es-la-vida-by-Daniel-Bar-and-Mickael-100%25', utils.slugify(arg,false)
+      end
+    end
+    describe 'when argument is nil' do
+      let(:arg) { nil }
+      it 'Does not break' do
+        assert_equal '', utils.slugify(arg)
+        assert_equal '', utils.slugify(arg,false)
+      end
+    end
+  end
+
+  describe '#label_for_field' do
+
+    # Returns a friendly name for a field name
+
+    it 'Returns an ideal title case version of the field name' do
+      [
+        ['hello', 'Hello'],
+        ['hello-world_1234', 'Hello World 1234'],
+        [:hello_world, 'Hello World'],
+      ].each do |(arg,result)|
+        assert_equal result, utils.label_for_field(arg)
+      end
+    end
+  end
+
+  describe '#each_stub' do
+    
+    # For iterating through end objects of a nested hash/array
+    # It would be used for updating values, typecasting them...
+
+    it 'Yields a block for every stub of a complex object and make changes possible' do
+      before = {
+        'name'=>"BoBBy",
+        'numbers'=>['One','Two'],
+        'meta'=>{'type'=>'Dev','tags'=>['Top','Bottom']}
+      }
+      after = {
+        'name'=>"bobby",
+        'numbers'=>['one','two'],
+        'meta'=>{'type'=>'dev','tags'=>['top','bottom']}
+      }
+      utils.each_stub(before) do |object,key_index,value|
+        object[key_index] = value.to_s.downcase
+      end
+      assert_equal after, before
+    end
+    it 'Raises a TypeError if The object is not appropriate' do
+      [nil,'yo',4].each do |obj|
+        assert_raises(TypeError) do
+          utils.each_stub(obj)
+        end
+      end
+    end
+  end
+
+  describe '#automatic_typecast' do
+
+    # Tries to do automatic typecasting of values
+    # that are received as strings, so most likely
+    # coming from a web form or from a CSV table.
+    #
+    # The purpose is to use it in combination with 
+    # #each_stub when a form is received by the API.
+
+    describe 'when a string' do
+      it 'Knows how to convert recognizable datatypes' do
+        [
+          ['true',true],
+          ['false',false],
+          ['',nil],
+          ['fack','fack'],
+          ['5', 5],
+          ['-5', -5],
+          ['42', 42],
+          ['-42', -42],
+          ['99.99', 99.99],
+          ['5.0', 5.0],
+          ['.4', 0.4],
+          ['-99.99', -99.99],
+          ['-5.0', -5.0],
+          ['-.4', -0.4],
+          ['42hello', '42hello'],
+          ['5.0hello', '5.0hello']
+        ].each do |(arg,result)|
+          assert_equal result, utils.automatic_typecast(arg)
+        end
+      end
+      it 'Can change what is typecasted' do
+        assert_equal '10', utils.automatic_typecast('10', [:bool,:nil])
+        assert_equal true, utils.automatic_typecast('true', [:bool,:nil])
+      end
+    end
+    describe 'when not a string' do
+      it 'Should leave it untouched' do
+        [Time.now,1.0].each do |obj|
+          assert_equal obj, utils.automatic_typecast(obj)
+        end
+      end
+    end
+  end
+
+  describe '#generate_random_id' do
+    it 'Has the correct format' do
+      assert_match /[a-zA-Z0-9]{16}/, utils.generate_random_id
+    end
+    it 'Can have a specific length' do
+      assert_match /[a-zA-Z0-9]{32}/, utils.generate_random_id(32)
+    end
+  end
+
+  describe '#nl2br' do
+    it 'Puts unclosed tags by default' do
+      assert_equal '<br>Hello<br>world<br>', utils.nl2br("\nHello\nworld\n")
+    end
+    describe 'with 2nd argument' do
+      it 'Replaces the tag' do
+        assert_equal '<br/>Hello<br/>world<br/>', utils.nl2br("\nHello\nworld\n",'<br/>')
+      end
+    end
+  end
+
+  describe '#complete_link' do
+    it 'Adds the external double slash when missing' do
+      [
+        ['www.web-utils.com','//www.web-utils.com'],
+        ['web-utils.com','//web-utils.com'],
+        ['please.web-utils.com','//please.web-utils.com'],
+      ].each do |(arg,result)|
+        assert_equal result, utils.complete_link(arg)
+      end
+    end
+    it 'Does not alter the url when it does not need double slash' do
+      [
+        ['//www.web-utils.com','//www.web-utils.com'],
+        ['://www.web-utils.com','://www.web-utils.com'],
+        ['http://www.web-utils.com','http://www.web-utils.com'],
+        ['ftp://www.web-utils.com','ftp://www.web-utils.com'],
+        ['mailto:web&#64;utils.com','mailto:web&#64;utils.com'],
+        ['',''],
+        [' ',' '],
+      ].each do |(arg,result)|
+        assert_equal result, utils.complete_link(arg)
+      end
+    end
+  end
+
+  describe '#external_link?' do
+    it 'Returns true when the link would need target=blank' do
+      [
+        ['http://web-utils.com', true],
+        ['https://web-utils.com', true],
+        ['ftp://web-utils.com', true],
+        ['://web-utils.com', true],
+        ['//web-utils.com', true],
+        ['mailto:user@web-utils.com', false],
+        ['mailto:user&#64;web-utils.com', false],
+        ['/web/utils', false],
+        ['web-utils.html', false],
+      ].each do |(url,bool)|
+        assert_equal bool, utils.external_link?(url)
+      end
+    end
+  end
+
+  describe '#automatic_html' do
+    it 'Automates links and line breaks' do
+      input = "Hello\nme@site.co.uk\nNot the begining me@site.co.uk\nme@site.co.uk not the end\nwww.site.co.uk\nVisit www.site.co.uk\nwww.site.co.uk rules\nhttp://www.site.co.uk\nVisit http://www.site.co.uk\nhttp://www.site.co.uk rules"
+      output = "Hello<br><a href='mailto:me&#64;site.co.uk'>me&#64;site.co.uk</a><br>Not the begining <a href='mailto:me&#64;site.co.uk'>me&#64;site.co.uk</a><br><a href='mailto:me&#64;site.co.uk'>me&#64;site.co.uk</a> not the end<br><a href='//www.site.co.uk' target='_blank'>www.site.co.uk</a><br>Visit <a href='//www.site.co.uk' target='_blank'>www.site.co.uk</a><br><a href='//www.site.co.uk' target='_blank'>www.site.co.uk</a> rules<br><a href='http://www.site.co.uk' target='_blank'>http://www.site.co.uk</a><br>Visit <a href='http://www.site.co.uk' target='_blank'>http://www.site.co.uk</a><br><a href='http://www.site.co.uk' target='_blank'>http://www.site.co.uk</a> rules"
+      assert_equal output, utils.automatic_html(input)
+    end
+  end
+
+  describe '#truncate' do
+    it 'Truncates to the right amount of letters' do
+      assert_equal 'abc...', utils.truncate('abc defg hijklmnopqrstuvwxyz',3)
+    end
+    it 'Does not cut words' do
+      assert_equal 'abcdefg...', utils.truncate('abcdefg hijklmnopqrstuvwxyz',3)
+    end
+    it 'Removes HTML tags' do
+      assert_equal 'abcdefg...', utils.truncate('<br>abc<a href=#>def</a>g hijklmnopqrstuvwxyz',3)
+    end
+    it 'Does not print the ellipsis if the string is already short enough' do
+      assert_equal 'abc def', utils.truncate('abc def',50)
+    end
+    describe 'with a 3rd argument' do 
+      it 'Replaces the ellipsis' do
+        assert_equal 'abc!', utils.truncate('abc defg hijklmnopqrstuvwxyz',3,'!')
+        assert_equal 'abc', utils.truncate('abc defg hijklmnopqrstuvwxyz',3,'')
+      end
+    end
+  end
+
+  describe '#display_price' do
+    it 'Turns a price number in cents/pence into a displayable one' do
+      assert_equal '45.95', utils.display_price(4595)
+    end
+    it 'Removes cents if it is 00' do
+      assert_equal '70', utils.display_price(7000)
+    end
+    it 'Adds comma delimiters on thousands' do
+      assert_equal '12,345,678.90', utils.display_price(1234567890)
+    end
+    it 'Works with negative numbers' do
+      assert_equal '-1,400', utils.display_price(-140000)
+    end
+    it 'Raises when argument is not int' do
+      assert_raises(TypeError) do
+        utils.display_price('abc')
+      end
+    end
+  end
+
+  describe '#parse_price' do
+    it 'Parses a string and find the price in cents/pence' do
+      assert_equal 4595, utils.parse_price('45.95')
+    end
+    it 'Works when you omit the cents/pence' do
+      assert_equal 2800, utils.parse_price('28')
+    end
+    it 'Ignores visual help but works with negative prices' do
+      assert_equal -1234567890, utils.parse_price('   £-12,345,678.90   ')
+    end
+    it 'Raises when argument is not string' do
+      assert_raises(TypeError) do
+        utils.parse_price(42)
+      end
+    end
+  end
+
+  describe '#branded_filename' do
+    it 'Adds WebUtils to the file name' do
+      assert_equal "/path/to/WebUtils-file.png", utils.branded_filename("/path/to/file.png")
+    end
+    it 'Works when there is just a file name' do
+      assert_equal "WebUtils-file.png", utils.branded_filename("file.png")
+    end
+    it 'Can change the brand' do
+      assert_equal "/path/to/Brand-file.png", utils.branded_filename("/path/to/file.png",'Brand')
+    end
+  end
+
+  describe '#filename_variation' do
+    it 'Replaces the ext with variation name and new ext' do
+      assert_equal "/path/to/file.thumb.gif", utils.filename_variation("/path/to/file.png", :thumb, :gif)
+    end
+    it 'Works when there is just a filename' do
+      assert_equal "file.thumb.gif", utils.filename_variation("file.png", :thumb, :gif)
+    end
+    it "Works when there is no ext to start with" do
+      assert_equal "/path/to/file.thumb.gif", utils.filename_variation("/path/to/file", :thumb, :gif)
+    end
+  end
+
+  describe '#initial_request?' do
+    let(:req) { 
+      Rack::Request.new(
+        Rack::MockRequest.env_for(
+          '/path', 
+          {'HTTP_REFERER'=>referer}
+        )
+      ) 
+    }
+    let(:referer) { nil }
+    it 'Returns true' do
+      assert utils.initial_request?(req)
+    end
+    describe 'Request comes from another domain' do
+      let(:referer) { 'https://www.google.com/path' }
+      it 'Returns true' do
+        assert utils.initial_request?(req)
+      end
+    end
+    describe 'Request comes from same domain' do
+      let(:referer) { 'http://example.org' }
+      it 'Returns false' do
+        refute utils.initial_request?(req)
+      end
+    end
+  end
+
+end
+

data/web-utils.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+
+  s.authors = ["Mickael Riga"]
+  s.email = ["mig@mypeplum.com"]
+  s.homepage = "https://github.com/mig-hub/web-utils"
+  s.licenses = ['MIT']
+
+  s.name = 'web-utils'
+  s.version = '0.0.1'
+  s.summary = "Web Utils"
+  s.description = "Useful web-related helper methods for models, views or controllers."
+
+  s.platform = Gem::Platform::RUBY
+  s.files = `git ls-files`.split("\n").sort
+  s.test_files = s.files.grep(/^test\//)
+  s.require_paths = ['lib']
+  s.add_dependency('rack', '~> 0')
+
+end
+

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: web-utils
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mickael Riga
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Useful web-related helper methods for models, views or controllers.
+email:
+- mig@mypeplum.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- lib/web_utils.rb
+- test/test_web_utils.rb
+- web-utils.gemspec
+homepage: https://github.com/mig-hub/web-utils
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Web Utils
+test_files:
+- test/test_web_utils.rb