tool_pouch 0.0.34

data/lib/tool_pouch/mathema.rb

@@ -0,0 +1,27 @@
+module ToolPouch::Mathema
+  def self.tax_for_amount(amount, region, options={})
+    options.reverse_merge!(:time => Time.now)
+
+    case region
+      when 'quebec' then get_quebec_taxes(amount, options)
+      else []
+    end
+  end
+
+  def self.get_quebec_taxes(amount, options={})
+    options.reverse_merge!(:time => Time.now)
+
+    gst = { :id => 'gst', :nature => 'tax', :rate => 0.05 }
+    qst = { :id => 'qst', :nature => 'tax' }
+
+    qst[:rate] = case
+      when options[:time] < Time.parse('2012-01-01') then 0.085
+      else 0.095
+    end
+
+    gst[:amount] = (amount * gst[:rate]).round
+    qst[:amount] = ((amount + gst[:amount]) * qst[:rate]).round
+
+    return [gst, qst]
+  end
+end

data/lib/tool_pouch/trail.rb

@@ -0,0 +1,279 @@
+require 'addressable/uri'
+
+module ToolPouch::Trail
+  def self.build_querystring(form_data)
+    query_string = ''
+    if form_data
+      params = []
+      if not form_data.empty?
+        form_data.each do |d|
+          if d[1].is_a?(Hash)
+            d[1].each do |key, value|
+              params << "#{d[0]}[#{key}]=#{CGI.escape(CGI.unescape(value.to_s))}"
+            end
+          else
+          params << "#{d[0]}=#{CGI.escape(CGI.unescape(d[1].to_s))}"
+          end
+        end
+      end
+      query_string =  params.sort.join('&')
+    end
+    return query_string
+  end
+
+  def self.directories(path)
+    directory = ''
+    if path and path.class == String
+      last_slash_index = path.rindex('/')
+
+      if last_slash_index.to_i > 0
+        directory = path[0, last_slash_index]
+      end
+    end
+
+    return directory
+  end
+
+  def self.extension(path)
+    file_extension = ''
+    if path
+      file_extension_with_dot = File.extname(path)
+      if not file_extension_with_dot.empty?
+        file_extension = file_extension_with_dot[1, file_extension_with_dot.length]
+      end
+    end
+    return file_extension
+  end
+
+  def self.filename_without_extension(path, options={})
+    options.reverse_merge!(:full_path => true)
+
+    filename = options[:full_path] ? path : filename_without_path(path)
+
+    return (filename and filename.rindex('.')) ? filename[0, filename.rindex('.')] : filename
+  end
+
+  def self.filename_without_path(path)
+    filename_without_path = path
+    if path
+      #Handle properly path without filename
+      if trailing_slash?(path)
+        filename_without_path = ''
+      else
+        filename_without_path = File.basename(path)
+      end
+    end
+    return filename_without_path
+  end
+
+  def self.get_domain(url)
+    domain = nil
+    if url
+      # add protocol so it becomes a valid URI
+      url = ('http://' + url) unless url =~ /^https?:\/\//
+
+      # remove %'s, which we don't need and could cause an URL to become invalid
+      url.gsub!('%', '')
+
+      begin
+        # get the host part, and remove the www. if present
+        domain = Addressable::URI.parse(url).host.gsub(/^www\./i, '')
+      rescue
+        ""
+      end
+    end
+    return domain
+  end
+
+  def self.get_all_files_with_extension(path, extensions=[])
+    extensions = [extensions] unless extensions.is_a? Array
+    extensions.collect!{|x| ".#{x}"}
+
+    files = []
+    Find.find(path) { |f| files << f if File.file?(f) and extensions.include? File.extname(f) }
+
+    return files
+  end
+
+  def self.get_file(root, filenames)
+    files = get_files(root, filenames)
+
+    return files.empty? ? nil : files.first
+  end
+
+  def self.get_files(root, filenames, options={})
+    options.reverse_merge!(:perfect_match => true)
+
+    filenames = [filenames] unless filenames.is_a? Array
+    root = slice_trailing_slash(root)
+    files = []
+
+    Find.find(root) do |f|
+      if options[:perfect_match]
+        files << f.gsub(root + '/', '') if File.file?(f) and filenames.include?(filename_without_path(f))
+      else
+        found = false
+        filename_only = filename_without_path(f)
+        filenames.each{ |m| found = true if filename_only.match(/#{m}/) }
+        files << f.gsub(root + '/', '') if File.file?(f) and found
+      end
+    end
+
+    return files
+  end
+
+  def self.get_first_file_with_extension(path, extensions=[])
+    return get_all_files_with_extension(path, extensions).first
+  end
+
+  def self.get_first_match(path, value)
+    File.open(path) do |io|
+      io.each do |line|
+        line.chomp!
+        return line if line.include? value
+      end
+    end
+
+    return nil
+  end
+
+  def self.get_querystring(url)
+    raw = URI.split(url)[7]
+
+    qs = {}
+
+    if raw
+      raw.split('&').each do |full_param|
+        key, value = full_param.split('=')
+        qs[key] = value
+      end
+    end
+
+    return qs
+  end
+
+  def self.get_section(url, options={})
+    section = nil
+    if url
+      if options[:base_path]
+        section = url.gsub(options[:base_path] + '/', '').split('/')[0]
+      else
+        section = url.split('/')[-1, 1].to_s
+      end
+
+      # Remove format if it was specified
+      section = File.basename(section, '.*')
+    end
+
+    return section
+  end
+
+  def self.is_file_with_extension?(path)
+    file_with_extension = false
+    if path
+      extension = File.extname(path)
+      if extension and not extension.empty?
+        file_with_extension = true
+      end
+    end
+    return file_with_extension
+  end
+
+  def self.is_url?(path)
+    return (path.to_s.include?('http://') or path.to_s.include?('https://')) ? true : false
+  end
+
+  def self.last_directory(path)
+    path += 'dummystring' if trailing_slash?(path)
+
+    return path.split('/')[-2, 1]
+  end
+
+  def self.open_and_merge(directories, options={})
+    options.reverse_merge!(:extensions => '')
+
+    directories = [directories] if not directories.is_a? Array
+
+    case options[:extensions]
+      when 'yml' then content = HashTree.new
+      else content = []
+    end
+
+    directories.each do |directory|
+      Find.find(directory) do |p|
+        next unless File.file?(p)
+
+        case options[:extensions]
+          when 'yml' then content.merge(yml_content(p))
+          when 'xml' then content << File.open(p, "r").readlines.join
+        end
+      end
+    end
+
+    case options[:extensions]
+      when 'yml' then content.get
+      else return content.join("\n")
+    end
+  end
+
+  def self.order_querystring_alpha(url)
+    ordered_url = url
+    if url and not url.strip.empty?
+      qs = URI.split(url)[7]
+
+      if qs
+        ordered_url = url.split('?')[0] + '?'
+        parameters = qs.split('&')
+        escaped_parameters = []
+        # Escape each parameter to ensure coherence with build_query_string
+        for parameter in parameters
+          name_value = parameter.split('=')
+          if name_value.size == 2
+            escaped_value = CGI.escape(CGI.unescape(name_value[1]))
+            escaped_parameters << "#{name_value[0]}=#{escaped_value}"
+          else
+            escaped_parameters << "#{name_value[0]}"
+          end
+        end
+        ordered_url << escaped_parameters.sort.join('&')
+        return ordered_url
+      end
+    end
+    return url
+  end
+
+  def self.partial_exists?(partial_short_path)
+    short_path = partial_short_path.split('/')
+    short_path[short_path.length-1] = '_' + short_path.last
+    return File.exists?(RAILS_ROOT + '/app/views' + short_path.join('/') + '.html.erb')
+  end
+
+  def self.refresh_file_content(path, content)
+    FileUtils.mkdir_p directories(path)
+    FileUtils.rm(path) if File.exists?(path)
+    File.open(path, 'w') {|f| f.write(content) }
+  end
+
+  def self.slice_trailing_slash(path)
+    return (trailing_slash?(path)) ? path.chop : path
+  end
+
+  def self.strip_scheme(uri)
+    uri.sub(/^#{Addressable::URI.parse(URI.encode(uri)).scheme}:\/\//,"")
+  end
+
+  def self.trailing_slash?(path)
+    trailing_slash = false
+    if path and path.length > 0
+      if path.slice(-1,1) == '/'
+        trailing_slash = true
+      end
+    end
+
+    return trailing_slash
+  end
+
+  def self.yml_content(file)
+    return YAML.load_file(file)
+  end
+end

data/lib/tool_pouch/transistor.rb

@@ -0,0 +1,98 @@
+require "addressable/uri"
+
+#*************************************************************************************
+# TOCOMMENT
+#*************************************************************************************
+module ToolPouch::Transistor
+  def self.get(raw_url, options={})
+    raw_url += '?' + ToolPouch::Trail.build_querystring(options.delete(:params)) if options[:params]
+
+    return send_request(:get, raw_url, options)
+  end
+
+  def self.get_head(url)
+    begin
+      uri = parse_uri(url)
+      res = Net::HTTP.start(uri.host, uri.port)
+    rescue
+      return false
+    end
+
+    return (res and res.head(url) ? res.head(url) : false)
+  end
+
+  def self.parse_uri(uri)
+    parsed_uri = Addressable::URI.parse(uri)
+    parsed_uri.port = 443 if parsed_uri.scheme == 'https'
+
+    return parsed_uri
+  end
+
+  def self.post(raw_url, options={})
+    send_request(:post, raw_url, options)
+  end
+
+  def self.send_request(method, raw_url, options={})
+    options.reverse_merge!(body: nil, content_type: nil, login: nil, params: {}, password: nil, timeout: nil)
+
+    url = parse_uri raw_url
+
+    request = "Net::HTTP::#{method.to_s.camelize}".constantize.new(url.request_uri)
+    request.basic_auth(options[:login], options[:password]) if options[:login]
+    request.body = options[:body] if options[:body]
+    request.content_type = options[:content_type] if options[:content_type]
+    request.set_form_data(options[:params]) if not options[:params].empty?
+
+    return start_net_http(url, request, timeout: options[:timeout])
+  end
+
+  def self.start_net_http(url, request, options={})
+    http = Net::HTTP.new(url.host, url.port)
+
+    if http
+      http.use_ssl = (url.scheme == 'https')
+      http.read_timeout = options[:timeout] if options[:timeout]
+
+      return http.start { |r| r.request(request) }
+    end
+
+    return nil
+  end
+
+  #*************************************************************************************
+  # Digest communication module
+  #*************************************************************************************
+  module Digest
+    def self.delete(url, password, form_data={})
+      form_data['_method'] = 'delete'
+
+      return post_request_digest(url, password, form_data)
+    end
+
+    def self.get(url, password)
+      url_digest = ToolPouch::Locksmith.build_digest_request(url, password)
+
+      if url_digest
+        uri = parse_uri url_digest
+
+        return Net::HTTP.get_response(uri) if uri
+      end
+
+      return nil
+    end
+
+    def self.post(url, password, form_data={})
+      url << ('?' + ToolPouch::Trail.build_querystring(form_data)) if not form_data.empty?
+
+      url_digest = ToolPouch::Locksmith.build_digest_request(url, password)
+
+      return Net::HTTP.post_form(parse_uri(url_digest), ToolPouch::Trail.get_querystring(url_digest))
+    end
+
+    def self.put(url, password, form_data={})
+      form_data['_method'] = 'put'
+
+      return post(url, password, form_data)
+    end
+  end
+end

data/lib/tool_pouch/version.rb

@@ -0,0 +1,3 @@
+module ToolPouch
+  VERSION = "0.0.34"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'tool_pouch'
+
+Time.zone = 'Eastern Time (US & Canada)'

data/spec/tool_pouch/krono_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe ToolPouch::Krono do
+  describe '#is_iso8601?' do
+    it "recognizes valid date" do
+      ToolPouch::Krono.is_iso8601?('2000-01-01T00:00:00-05:00').should be_true
+      ToolPouch::Krono.is_iso8601?('1900-01-01T00:00:00-05:00').should be_true
+      ToolPouch::Krono.is_iso8601?('1800-01-01T00:00:00-05:00').should be_true
+      ToolPouch::Krono.is_iso8601?('1700-01-01T00:00:00-05:00').should be_true
+    end
+  end
+end

data/spec/tool_pouch/locksmith/digest_spec.rb

@@ -0,0 +1,105 @@
+require "spec_helper"
+require 'addressable/uri'
+
+describe ToolPouch::Locksmith do
+  let (:password) {'ThiZizAS3cr3T'}
+
+  describe 'digesting an URL' do
+    it "works without an URL authority" do
+      url = "/home"
+      digested_url = ToolPouch::Locksmith.build_digest_request(url, password)
+
+      ToolPouch::Locksmith.check_digest_request(digested_url, password).should be_true
+    end
+
+    it "works without an URL query" do
+      url = "http://example.org"
+      digested_url = ToolPouch::Locksmith.build_digest_request(url, password)
+
+      ToolPouch::Locksmith.check_digest_request(digested_url, password).should be_true
+    end
+
+    it "works regardless of the scheme use (http vs https)" do
+      url = "https://example.org"
+      digested_url = ToolPouch::Locksmith.build_digest_request(url, password)
+      digested_url.gsub! /https:\/\//, 'http://'
+
+      ToolPouch::Locksmith.check_digest_request(digested_url, password).should be_true
+    end
+
+    it "allows specifying a lifespan" do
+      url = "http://example.org"
+      digested_url = ToolPouch::Locksmith.build_digest_request(url, password, 30.seconds)
+
+      ToolPouch::Locksmith.check_digest_request(digested_url, password).should be_true
+    end
+
+    it "works with an URL query" do
+      url = "http://example.org?key=value"
+      digested_url = ToolPouch::Locksmith.build_digest_request(url, password)
+
+      ToolPouch::Locksmith.check_digest_request(digested_url, password).should be_true
+    end
+
+    it "orders the query parameters" do
+      url = "http://example.org?b=1&c=1&a=1"
+      digested_url = ToolPouch::Locksmith.build_digest_request(url, password)
+
+      digested_url.should match /http:\/\/example.org\?a=1&b=1&c=1/
+    end
+
+    it "works regardless of the orders of URL query parameters" do
+      url = "http://example.org?b=1&c=1&a=1"
+      digested_url = ToolPouch::Locksmith.build_digest_request(url, password)
+      digested_url_with_different_orders = digested_url.gsub /a=1&b=1&c=1/, 'c=1&a=1&b=1'
+
+      ToolPouch::Locksmith.check_digest_request(digested_url_with_different_orders, password).should be_true
+    end
+
+    it "works regardless of using percent encoded characters or real characters in the query" do
+      url = "http://example.org?key=%C3%97"
+      digested_url = ToolPouch::Locksmith.build_digest_request(url, password)
+      unescaped_digested_url = digested_url.gsub /%C3%97/, '×'
+      ToolPouch::Locksmith.check_digest_request(unescaped_digested_url, password).should be_true
+
+      url = "http://example.org?key=×"
+      digested_url = ToolPouch::Locksmith.build_digest_request(url, password)
+      escaped_digested_url = digested_url.gsub /×/, '%C3%97'
+      ToolPouch::Locksmith.check_digest_request(escaped_digested_url, password).should be_true
+    end
+
+    it "does not allow token hacking" do
+      url = "http://example.org?key=value"
+      digested_url = ToolPouch::Locksmith.build_digest_request(url, password)
+      hacked_url = digested_url.gsub /token=/, 'token=X'
+
+      ToolPouch::Locksmith.check_digest_request(hacked_url, password).should be_false
+    end
+
+    it "does not allow an expired URL" do
+      url = "http://example.org"
+      digested_url = ToolPouch::Locksmith.build_digest_request(url, password, 2.seconds)
+      sleep 3
+
+      ToolPouch::Locksmith.check_digest_request(digested_url, password).should be_false
+    end
+
+    it "works regardless of the port used" do
+      url = "https://example.org:443"
+      digested_url = ToolPouch::Locksmith.build_digest_request(url, password)
+      digested_url.gsub! /:443/, ''
+      ToolPouch::Locksmith.check_digest_request(digested_url, password).should be_true
+
+      digested_url = ToolPouch::Locksmith.build_digest_request(url, password)
+      digested_url.gsub! /:443/, ':80'
+      ToolPouch::Locksmith.check_digest_request(digested_url, password).should be_true
+    end
+
+    it "keeps the port in the generated URL" do
+      url = "https://example.org:443"
+      digested_url = ToolPouch::Locksmith.build_digest_request(url, password)
+      digested_url.should match /:443/
+    end
+  end
+
+end