Class: Juno::Transformer

Inherits:

Proxy

• Object
• Base
• Proxy
• Juno::Transformer

Defined in:

lib/juno/transformer.rb

Overview

Transforms keys and values (Marshal, YAML, JSON, Base64, MD5, …).

Examples:

Add transformer to chain

Juno.build do
  transformer :key => [:marshal, :escape], :value => [:marshal]
  adapter :File, :dir => 'data'
end

Constant Summary

TRANSFORMER =

Available key/value transformers

{
  # Name    => [ Type,       Load,                              Dump,                                Library         ],
  :bencode  => [ :serialize, '::BEncode.load(value)',           '::BEncode.dump(value)',             'bencode'       ],
  :bert     => [ :serialize, '::BERT.decode(value)',            '::BERT.encode(value)',              'bert'          ],
  :bson     => [ :serialize, "::BSON.deserialize(value)['v']",  "::BSON.serialize('v'=>value).to_s", 'bson'          ],
  :json     => [ :serialize, '::MultiJson.load(value).first',   '::MultiJson.dump([value])',         'multi_json'    ],
  :marshal  => [ :serialize, '::Marshal.load(value)',           '::Marshal.dump(value)'                              ],
  :msgpack  => [ :serialize, '::MessagePack.unpack(value)',     '::MessagePack.pack(value)',         'msgpack'       ],
  :ox       => [ :serialize, '::Ox.parse_obj(value)',           '::Ox.dump(value)',                  'ox'            ],
  :tnet     => [ :serialize, '::TNetstring.parse(value).first', '::TNetstring.dump(value)',          'tnetstring'    ],
  :yaml     => [ :serialize, '::YAML.load(value)',              '::YAML.dump(value)',                'yaml'          ],
  :lzma     => [ :compress,  '::LZMA.decompress(value)',        '::LZMA.compress(value)',            'lzma'          ],
  :lzo      => [ :compress,  '::LZO.decompress(value)',         '::LZO.compress(value)',             'lzoruby'       ],
  :snappy   => [ :compress,  '::Snappy.inflate(value)',         '::Snappy.deflate(value)',           'snappy'        ],
  :quicklz  => [ :compress,  '::QuickLZ.decompress(value)',     '::QuickLZ.compress(value)',         'qlzruby'       ],
  :zlib     => [ :compress,  '::Zlib::Inflate.inflate(value)',  '::Zlib::Deflate.deflate(value)',    'zlib'          ],
  :base64   => [ :encode,    "value.unpack('m').first",         "[value].pack('m').strip"                            ],
  :uuencode => [ :encode,    "value.unpack('u').first",         "[value].pack('u').strip"                            ],
  :escape   => [ :encode,    "value.gsub(/((?:%[0-9a-fA-F]{2})+)/){ [$1.delete('%')].pack('H*') }",
                             "value.gsub(/[^a-zA-Z0-9_-]+/){ '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase }" ],
  :md5      => [ :digest,    nil,                               '::Digest::MD5.hexdigest(value)',    'digest/md5'    ],
  :rmd160   => [ :digest,    nil,                               '::Digest::RMD160.hexdigest(value)', 'digest/rmd160' ],
  :sha1     => [ :digest,    nil,                               '::Digest::SHA1.hexdigest(value)',   'digest/sha1'   ],
  :sha256   => [ :digest,    nil,                               '::Digest::SHA256.hexdigest(value)', 'digest/sha2'   ],
  :sha384   => [ :digest,    nil,                               '::Digest::SHA384.hexdigest(value)', 'digest/sha2'   ],
  :sha512   => [ :digest,    nil,                               '::Digest::SHA512.hexdigest(value)', 'digest/sha2'   ],
  :prefix   => [ :prefix,    nil,                               '@prefix+value'                                      ],
  :spread   => [ :spread,    nil,                               '(tmp = value; ::File.join(tmp[0..1], tmp[2..-1]))'  ],
}

VALUE_TRANSFORMER =

Allowed value transformers (Read it like a regular expression!)

compile_validator('serialize? compress? encode?')

KEY_TRANSFORMER =

Allowed key transformers (Read it like a regular expression!)

compile_validator('serialize? prefix? (encode | (digest spread?))?')

Instance Attribute Summary

Attributes inherited from Proxy

#adapter

Class Method Summary

• .new(adapter, options = {}) ⇒ Object

  Constructor.

• .original_new ⇒ Object

Instance Method Summary

• #initialize(adapter, options = {}) ⇒ Transformer constructor

  A new instance of Transformer.

Methods inherited from Proxy

#clear, #close, #delete, #key?, #load, #store

Methods inherited from Base

#[], #[]=, #close, #fetch

Constructor Details

#initialize(adapter, options = {}) ⇒ Transformer

Returns a new instance of Transformer.

# File 'lib/juno/transformer.rb', line 12

def initialize(adapter, options = {})
  super
  @prefix = options[:prefix]
end

Class Method Details

.new(adapter, options = {}) ⇒ Object

Constructor

Options:

• :key - List of key transformers in the order in which they should be applied

• :value - List of value transformers in the order in which they should be applied

• :prefix - Prefix string for key namespacing (Used by the :prefix key transformer)

# File 'lib/juno/transformer.rb', line 29

def new(adapter, options = {})
  keys = [options[:key]].flatten.compact
  values = [options[:value]].flatten.compact
  raise 'Option :key or :value is required' if keys.empty? && values.empty?
  raise 'Option :prefix is required' if keys.include?(:prefix) && !options[:prefix]
  name = ''
  name << keys.map(&:to_s).map(&:capitalize).join << 'Key' unless keys.empty?
  name << values.map(&:to_s).map(&:capitalize).join << 'Value' unless values.empty?
  const_set(name, compile(keys, values)) unless const_defined?(name)
  const_get(name).original_new(adapter, options)
end

.original_new ⇒ Object

# File 'lib/juno/transformer.rb', line 18

alias_method :original_new, :new