shrinker 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--debugger

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3-p194@shrinker --install --create

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in shrinker.gemspec
+gemspec
+
+gem 'rspec'
+gem 'debugger'
+gem 'redis'
+gem 'mail'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 jrichardlai
+
+MIT License
+
+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,83 @@
+# Shrinker
+
+Replace all occurence of a domain and create a shortened link using a token.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'shrinker'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install shrinker
+
+## Usage
+
+
+```ruby
+Shrinker.configure do
+  backend 'Redis'
+  backend_options client: {port: 6388, host: '192.168.12.22'}
+  expanded_domain /(www.)?google.com/ # this also works with protocol
+  exclude_path /assets|images/
+  anchors\_only\_in_html true         # With the mime only replace the links inside an anchor
+  shrinked_domain 'go.com'
+end
+```
+
+Not shrinking a link `www.google.com?shrinker=false&something=else` would be replaced by `www.google.com?something=else`.
+
+Usage on a text:
+
+```ruby
+
+text = <<-EV
+  Lorem ipsum dolor sit amet, consectetur adipiscing elit. 
+  Nunc quis rutrum http://www.google.com?something=true&else=false dolor. 
+  Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos.
+  Curabitur ullamcorper nisl non dolor http://google.fr?something=true venenatis consequat.
+  Morbi odio libero, tincidunt quis tempus a, fringilla vitae augue.
+  http://google.com/somepath?something=true
+  Aenean placerat ullamcorper lorem vel feugiat.
+EV
+
+
+new_text = Shrinker::Parser::Text.replace(text, {:user_id => 123})
+
+new_text # => 
+# Lorem ipsum dolor sit amet, consectetur adipiscing elit. 
+# Nunc quis rutrum http://go.com/token1 dolor. 
+# Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos.
+# Curabitur ullamcorper nisl non dolor http://google.fr?something=true venenatis consequat.
+# Morbi odio libero, tincidunt quis tempus a, fringilla vitae augue.
+# http://go.com/token2
+# Aenean placerat ullamcorper lorem vel feugiat.
+
+```
+
+With a MIME:
+
+```ruby
+new_mime = Shrinker::Parser::Mime.replace(mime, {:user_id => 123})
+```
+
+Get back a real link:
+
+```ruby
+url = Shrinker::unshrink(token)
+url.to_s # => 'http://google.com/something=true'
+url.attributes['user_id'] # => 123
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/shrinker/backend/abstract.rb

@@ -0,0 +1,25 @@
+module Shrinker
+  module Backend
+    class Abstract
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def store(raw_url, token, attributes = {})
+        raise "Shrinker::Backend::Abstract.store not implemented"
+      end
+
+      def fetch(token)
+        raise "Shrinker::Backend::Abstract.fetch not implemented"
+      end
+
+      private
+
+      def ttl
+        options[:expires_in]
+      end
+    end
+  end
+end

data/lib/shrinker/backend/redis.rb

@@ -0,0 +1,56 @@
+module Shrinker
+  module Backend
+    class Redis < Abstract
+      require 'redis'
+
+      def initialize(options = {})
+        super
+        @client_options = options[:client] || {}
+        @namespace      = options[:namespace] || '_shrinker'
+      end
+
+      def store(raw_url, token, attributes = {})
+        content   = Shrinker::Serializer::to_json(raw_url, attributes)
+        redis_key = key(token)
+        if ttl
+          client.setex(redis_key, ttl, content)
+        else
+          client.set(redis_key, content)
+        end
+      end
+
+      def fetch(token)
+        content = client.get(key(token))
+
+        return {} unless content
+        Shrinker::Serializer::from_json(content)
+      end
+
+      def used_token?(token)
+        !!client.get(key(token))
+      end
+
+      protected
+
+      def client
+        @client ||= begin
+          ::Redis.new(@client_options)
+        end
+      end 
+
+      def delete(token)
+        client.del(key(token))
+      end
+
+      def clear!(pattern = nil)
+        client.keys("#{@namespace}::#{pattern || '*'}").each do |key|
+          client.del(key)
+        end
+      end
+
+      def key(token)
+        [@namespace, token].compact.join('::')
+      end
+    end
+  end
+end

data/lib/shrinker/config.rb

@@ -0,0 +1,83 @@
+module Shrinker
+  class Config
+
+    # provides a getter and a setter with the same method
+    # config_setting :dog
+    #   --> dog 'Husky' :=> 'Husky' (setter)
+    #   --> dog :=> 'Husky' (getter)
+
+    def self.settings
+      @settings ||= []
+    end
+
+    def self.config_setting(name)
+      settings << name
+
+      class_eval <<-EV, __FILE__, __LINE__ + 1
+        attr_reader :#{name}
+        
+        def #{name}(value = nil)
+          return @#{name} if value.nil?
+          @#{name} = value
+          value
+        end          
+      EV
+    end
+
+    # the backend to be used to store the real url
+    config_setting :backend
+
+    # the options to pass to the backend
+    config_setting :backend_options
+
+    # domain to be shrinked can be a regex
+    config_setting :expanded_pattern
+
+    # regex for the url path to be excluded
+    config_setting :exclude_path
+
+    # regex to mactch/exclude the pattern when matching around patterns
+    config_setting :around_pattern
+
+    # domain to be used when shrinking the urls
+    config_setting :shrinked_pattern
+
+    # setting boolean to replace links only in anchor tags href inside html
+    config_setting :anchors_only_in_html
+
+    def ==(config)
+      self.class.settings.each { |setting| send(setting) == config.send(setting) }
+    end
+
+    def reset!
+      self.instance_variables.each do |var|
+        self.instance_variable_set(var, nil)
+      end
+    end
+
+    def merge(config)
+      new_config = Config.new
+      new_config.merge!(config)
+
+      new_config
+    end
+
+    def merge!(config)
+      case config
+      when self.class
+        self.class.settings.each { |setting| send(setting, config.send(setting)) }
+      when Hash
+        config.each_pair do |setting, value|
+          send(setting, value)
+        end
+      end
+    end
+
+    def backend_instance
+      @backend_instance ||= begin
+        class_name = (backend || 'Abstract').to_s
+        ::Shrinker::Backend.const_get(class_name).new(backend_options || {})
+      end
+    end
+  end
+end

data/lib/shrinker/easy_url.rb

@@ -0,0 +1,36 @@
+module Shrinker
+  class EasyUrl < Struct.new(:url, :attributes)
+    require 'cgi'
+
+    def =~(regexp)
+      to_s =~ regexp
+    end
+
+    def to_s
+      parsed_uri.query = to_param
+      parsed_uri.query = nil if parsed_uri.query == ''
+      parsed_uri.to_s
+    end
+
+    def params
+      @params ||= begin
+        hash = {}
+        CGI.parse(parsed_uri.query).each_pair do |key, value|
+          hash[key.to_sym] = value.length == 1 ? value.first : value
+        end if parsed_uri.query
+        hash
+      end
+    end
+
+    protected
+
+     def to_param
+      return params.to_param('') if params.respond_to?(:to_param)
+      params.collect { |key, value| "#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}" }.join("&")
+    end
+
+    def parsed_uri
+      @parsed_uri ||= URI.parse(url)
+    end
+  end
+end

data/lib/shrinker/extractor.rb

@@ -0,0 +1,24 @@
+module Shrinker
+  class Extractor < Struct.new(:token, :config)
+    def self.unshrink(token, config = nil)
+      self.new(token, config).unshrink
+    end
+
+    def unshrink
+      stored_content = backend.fetch(token)
+      raise UrlNotFound.new("Cannot find the url with token: #{token}") if stored_content == {}
+
+      EasyUrl.new(stored_content['url'], stored_content['attributes'] || {})
+    end
+
+    protected
+
+    def backend
+      config.backend_instance
+    end
+
+    def config
+      super || Shrinker.config
+    end
+  end
+end

data/lib/shrinker/parser/abstract.rb

@@ -0,0 +1,58 @@
+module Shrinker
+  module Parser
+    class Abstract < Struct.new(:content, :attributes)
+      attr_reader :config
+
+      # Delegate replace to an instance
+      def self.replace(content, attributes = {}, config = nil)
+        self.new(content, attributes, config).replace
+      end
+
+      def initialize(content = nil, attributes = nil, config = nil)
+        super(content, attributes)
+        merge_config(config)
+      end
+
+      def replace
+        raise "Shrinker::Parser::Abstract.replace not implemented"
+      end
+
+      protected
+
+      def url_regex
+        return base_url_regex if around_pattern.to_s == ''
+
+        Regexp.new around_pattern.to_s.gsub('$url', base_url_regex.to_s)
+      end
+
+      def base_url_regex
+        /(#{expanded_pattern}[-A-Z0-9+&@#\/%?=~_|$!:,.;]*[-A-Z0-9+&@#\/%=~_|$])/i
+      end
+
+      def excluded_path_regex
+        config.exclude_path
+      end
+
+      def expanded_pattern
+        config.expanded_pattern
+      end
+
+      def around_pattern
+        config.around_pattern
+      end
+
+      def shrinked_pattern
+        config.shrinked_pattern
+      end
+
+      def backend
+        config.backend_instance
+      end
+
+      def merge_config(config)
+        @config ||= Shrinker.config.dup
+        @config.merge!(config)
+      end
+    end
+  end
+end

data/lib/shrinker/parser/mime.rb

@@ -0,0 +1,44 @@
+module Shrinker
+  module Parser
+    class Mime < Abstract
+      require 'mail'
+
+      def replace
+        parts = email.all_parts.empty? ? [email] : email.all_parts
+
+        parts.each do |part|
+          new_body  = replace_part_body(part)
+          part.body = if part.content_transfer_encoding
+                        Mail::Body.new(new_body).encoded(part.content_transfer_encoding)
+                      else
+                        new_body.to_s
+                      end
+        end
+        email.to_s
+      end
+
+      def email
+        @email ||= Mail.read_from_string(content)
+      end
+
+      def replace_part_body(part)
+        replace_config = config.dup
+        if part.mime_type == "text/html" && anchors_only_in_html? 
+          replace_config.merge!({:around_pattern => anchor_tag_around_regex})
+        end
+
+        Text::replace(part.body.decoded, attributes, replace_config)
+      end
+
+      private 
+
+      def anchor_tag_around_regex
+        /href="(?:https?:\/\/)?($url)"/
+      end
+
+      def anchors_only_in_html?
+        config.anchors_only_in_html == true
+      end
+    end
+  end
+end

data/lib/shrinker/parser/text.rb

@@ -0,0 +1,21 @@
+module Shrinker
+  module Parser
+    class Text < Abstract
+      def replace
+        content.gsub(url_regex) do |url|
+          matched_url = $1
+
+          next if matched_url =~ excluded_path_regex
+
+          url.gsub!(matched_url, shrink_url(matched_url))
+        end
+      end
+
+      protected
+
+      def shrink_url(url)
+        Url::replace(url, attributes, config)
+      end
+    end
+  end
+end

data/lib/shrinker/parser/url.rb

@@ -0,0 +1,41 @@
+module Shrinker
+  module Parser
+    class Url < Abstract
+      def replace
+        return url.to_s if url.params.delete(:shrinker).to_s == 'false'
+        return url.to_s if url =~ excluded_path_regex
+
+        new_url = url.to_s
+        new_url = shrink if new_url =~ url_regex
+
+        new_url
+      end
+
+      def shrink
+        token = Token.fetch_unique_token(backend, prefix: "__#{attributes.to_json}__#{content}")
+        backend.store(content, token, attributes)
+
+        if shrinked_pattern.respond_to?(:call)
+          if match = url.to_s.match(expanded_pattern)
+            start = shrinked_pattern.call(match)
+          else
+            # just bail out
+            return url.to_s
+          end
+        else
+          start = shrinked_pattern.to_s
+        end
+        
+        [start, token].join("/")
+      end
+
+      def url
+        @url ||= EasyUrl.new(content)
+      end
+
+      def url_regex
+        base_url_regex
+      end
+    end
+  end
+end

data/lib/shrinker/serializer.rb

@@ -0,0 +1,20 @@
+module Shrinker
+  module Serializer
+    extend self
+
+    def to_json(raw_url, attributes = {})
+      to_hash(raw_url, attributes).to_json
+    end
+
+    def to_hash(raw_url, attributes = {})
+      {:url => raw_url, :attributes => (attributes || {})}
+    end
+
+    # symbolize keys from the json if with_indifferent_access exists
+    def from_json(content)
+      hash = JSON.parse(content)
+      hash = hash.with_indifferent_access if hash.respond_to?(:with_indifferent_access)
+      hash
+    end
+  end
+end

data/lib/shrinker/token.rb

@@ -0,0 +1,23 @@
+module Shrinker
+  module Token
+    require 'digest/md5'
+
+    extend self
+
+    def fetch_unique_token(backend, options = {})
+      need_token = true
+
+      while need_token
+        token      = generate(options)
+        need_token = backend.used_token?(token)
+      end
+
+      token
+    end
+
+    def generate(options = {})
+      prefix = options[:prefix]
+      Digest::MD5.hexdigest("#{prefix}__#{rand(99999)}")[-12..-1]
+    end
+  end
+end

data/lib/shrinker/version.rb

@@ -0,0 +1,13 @@
+module Shrinker
+  module VERSION
+
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 0
+    PRE   = nil
+
+    def self.to_s
+      [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+    end
+  end
+end

data/lib/shrinker.rb

@@ -0,0 +1,48 @@
+require "shrinker/version"
+require "json"
+
+module Shrinker
+  autoload :Config,     'shrinker/config'
+  autoload :Serializer, 'shrinker/serializer'
+  autoload :Extractor,  'shrinker/extractor'
+  autoload :EasyUrl,    'shrinker/easy_url'
+  autoload :Token,      'shrinker/token'
+
+  module Backend
+    autoload :Abstract, 'shrinker/backend/abstract'
+    autoload :Redis,    'shrinker/backend/redis'
+  end
+
+  module Parser
+    autoload :Abstract, 'shrinker/parser/abstract'
+    autoload :Url,      'shrinker/parser/url'
+    autoload :Text,     'shrinker/parser/text'
+    autoload :Mime,     'shrinker/parser/mime'
+  end
+
+  class UrlNotFound < ArgumentError; end;
+
+  class << self
+    def configure(&block)
+      if block_given?
+        configuration.instance_eval(&block)
+      end
+      configuration
+    end
+    alias_method :config, :configure
+
+    def unshrink(token)
+      Shrinker::Extractor::unshrink(token, config)
+    end
+
+    protected
+
+    def configuration
+      @configuration ||= ::Shrinker::Config.new
+    end
+
+    def backend
+      config.backend_instance
+    end
+  end
+end

data/shrinker.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'shrinker/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "shrinker"
+  gem.version       = Shrinker::VERSION
+  gem.authors       = ["jrichardlai"]
+  gem.email         = ["jrichardlai@gmail.com"]
+  gem.description   = %q{Find links in a text and shorten them}
+  gem.summary       = %q{Find links in a text and shorten them}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.add_dependency('json')
+end