liquid-ext 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ccafb95dc4aafbdfcc5c4c75916926fa9a332dcd
+  data.tar.gz: 6e9e8d993ae413ca7d0630ea68dc469061195c54
+SHA512:
+  metadata.gz: 509061281f8ba50abbcf3463d0c946fbe3fdf1286a6520617fb074f6e9aea4eb1539c88973d1ae59f10f3d22859f34608d79e206d918c28cec43f69715ade016
+  data.tar.gz: 697911fda7ae6c9a56c1f50a56e535fbda9bea71702af6b3d036b3d338544b79e8f773c5e18a4e891d5320d446bce476e2321af7151b8117ca4498411ff2538a

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/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - jruby
+  - 2.0.0
+  - 1.9.3

data/.yardopts

@@ -0,0 +1 @@
+--protected --no-private

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem "liquid-development"
+end

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2012 madvertise Mobile Advertising GmbH
+Copyright (c) 2013 LiquidM, Inc.
+
+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,33 @@
+# Liquid Extensions
+
+The liquid-ext gem provides a bunch of ruby extensions and common startup/runtime code.
+
+[![Build Status](https://secure.travis-ci.org/liquidm/ext.png)](http://travis-ci.org/liquidm/ext)
+[![Code Climate](https://codeclimate.com/github/liquidm/ext.png)](https://codeclimate.com/github/liquidm/ext)
+[![Dependency Status](https://gemnasium.com/liquidm/ext.png)](https://gemnasium.com/liquidm/ext)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'liquid-ext'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install liquid-ext
+
+## Usage
+
+Please refer to the [API documentation](http://rubydoc.info/gems/liquid-ext/frames).
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+require "bundler/gem_tasks"
+require "liquid/tasks"

data/lib/liquid/benchmark.rb

@@ -0,0 +1,9 @@
+java_import 'java.lang.System'
+
+module Benchmark
+  def realtime(&block)
+    t0 = System.nano_time
+    yield
+    ((System.nano_time - t0).to_f / 1_000_000_000).round(3)
+  end
+end

data/lib/liquid/boot.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+$:.unshift(ROOT) if defined?(ROOT)
+
+# load default configuration
+require 'liquid-logging'
+require 'liquid/configuration'
+
+$conf = Configuration.new
+
+# configuration-reloading callbacks
+reload_logger = ->(conf) do
+  ImprovedLogger::Formatter.format = conf.log_format
+  ImprovedLogger::Formatter.log4j_format = conf.log4j_format
+
+  $log = MultiLogger.new
+  $log.attach(ImprovedLogger.new(conf.log_backend.to_sym, File.basename($0)))
+  $log.level = conf.log_level.downcase.to_sym
+  $log.log_caller = conf.log_caller
+
+  # sneak this in automatically
+  ZK.logger = $log if ::Module.const_defined?(:ZK)
+end
+
+reload_mixins = ->(conf) do
+  if defined?(ROOT)
+    config_yml = File.join(ROOT, 'config.yml')
+    conf.mixin(config_yml) if File.exist?(config_yml)
+
+    dot_user = File.join(ROOT, '.user')
+
+    if File.exists?(dot_user)
+      File.readlines(dot_user).each do |line|
+        user_yml = File.join(ROOT, 'config', 'mixins', "#{line.chomp}.yml")
+        conf.mixin(user_yml)
+      end
+    end
+  end
+end
+
+# reload configuration, trigger callbacks
+$conf.callback(&reload_mixins)
+$conf.callback(&reload_logger)
+
+$conf.reload!
+
+# load java dependencies
+if RUBY_PLATFORM == 'java'
+  begin
+    require 'jbundler'
+  rescue LoadError
+    # do nothing
+  end
+
+  # some java libraries cannot be found on maven central, so we load all bundled
+  # jar files here for convenience
+  if defined?(ROOT)
+    Dir[File.join(ROOT, 'jars', '*.jar')].each do |f|
+      require f
+    end
+  end
+end
+
+# load a bunch of common classes here, so we don't have to track and repeat it
+# everywhere
+require 'active_support/all'
+require 'cgi'
+require 'date'
+require 'json'
+require 'socket'
+require 'time'
+
+# load all extensions
+Dir[File.join(File.dirname(__FILE__), 'ext', '*.rb')].each do |f|
+  require f
+end
+
+if RUBY_PLATFORM == 'java'
+  require 'liquid/benchmark'
+end
+
+require 'liquid/cli'
+require 'liquid/environment'
+require 'liquid/from_file'
+require 'liquid/hash_helper'
+require 'liquid/transaction_id'

data/lib/liquid/cli.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+require 'liquid/boot'
+require 'mixlib/cli'
+
+class CLI
+  include Mixlib::CLI
+
+  option :configfile,
+    short: '-c FILE',
+    long: '--config FILE',
+    description: 'Configuration File to load'
+
+  option :name,
+    :short => '-n NAME',
+    :long => '--name NAME',
+    :description => 'Process name',
+    :default => File.basename($0),
+    :proc => ->(value) { $0 = value }
+
+  option :environment,
+    :short => '-e ENVIRONMENT',
+    :long => '--environment ENVIRONMENT',
+    :description => "Set the daemon environment",
+    :default => "development",
+    :proc => ->(value) { Env.set(value) }
+
+  option :debug,
+    :short => '-D',
+    :long => '--debug',
+    :description => "Enable debug output",
+    :boolean => true,
+    :default => false,
+    :proc => ->(value) { $conf.mixin(log_level: value ? :debug : :info); value }
+
+  option :help,
+    :short => '-h',
+    :long => '--help',
+    :description => "Show this message",
+    :on => :tail,
+    :boolean => true,
+    :show_options => true,
+    :exit => 0
+
+  def option(name, args)
+    args[:on] ||= :on
+    args[:boolean] ||= false
+    args[:required] ||= false
+    args[:proc] ||= nil
+    args[:show_options] ||= false
+    args[:exit] ||= nil
+
+    if args.has_key?(:default)
+      config[name.to_sym] = args[:default]
+    end
+
+    options[name.to_sym] = args
+  end
+
+  def self.for(cls, &block)
+    cli = new
+    cli.instance_eval(&block) if block_given?
+    cli.parse_options
+
+    $log.info("cli:initialize", cli.config)
+    $conf.reload!
+
+    # infer some variables
+    opts = cli.config.merge({
+      fqdn: Socket.gethostbyname(Socket.gethostname).first
+    })
+
+    # sneak in opts without subclassing
+    cls.allocate.tap do |obj|
+      obj.define_singleton_method(:opts) { opts }
+      obj.send(:initialize)
+    end
+  end
+
+end

data/lib/liquid/configuration.rb

@@ -0,0 +1,158 @@
+# encoding: utf-8
+
+require 'yaml'
+require 'set'
+
+require 'liquid/ext/hash'
+require 'liquid/ext/ordered_set'
+require 'liquid/environment'
+
+##
+# A {Configuration} consists of one or more Sections. A section is a hash-like
+# object that responds to all keys in the hash as if they were methods:
+#
+#   > s = Section.from_hash({:v1 => 2, :nested => {:v2 => 1}})
+#   > s.v1
+#   => 2
+#   > s.nested.v2
+#   => 1
+#
+class Section < Hash
+
+  class << self
+
+    # How to handle nil values in the configuration?
+    #
+    # Possible values are:
+    #  - :nil, nil  (return nil)
+    #  - :raise  (raise an exception)
+    #  - :section  (return a NilSection which can be chained)
+    #
+    attr_accessor :nil_action
+
+    # Create a new section from the given hash-like object.
+    #
+    # @param [Hash] hsh  The hash to convert into a section.
+    # @return [Section]  The new {Section} object.
+    def from_hash(hsh)
+      new.tap do |result|
+        hsh.each do |key, value|
+          result[key.to_sym] = from_value(value)
+        end
+      end
+    end
+
+    # Convert the given value into a Section, list of Sections or the pure
+    # value. Used to recursively build the Section hash.
+    #
+    # @private
+    def from_value(value)
+      case value
+      when Hash
+        from_hash(value)
+      when Array
+        value.map do |item|
+          from_value(item)
+        end
+      else
+        value
+      end
+    end
+
+  end
+
+  # @private
+  def method_missing(name, *args)
+    if name.to_s =~ /(.*)=$/
+      self[$1.to_sym] = Section.from_value(args.first)
+    else
+      value = self[name]
+      self[name] = value.call if value.is_a?(Proc)
+      self[name]
+    end
+  end
+end
+
+##
+# The Configuration class provides a simple interface to configuration stored
+# inside of YAML files.
+#
+class Configuration < Section
+
+  DEFAULTS = {
+    generic: {
+      log_backend: :stdout,
+      log_caller: false,
+      log_level: :info,
+      log_format: "%{time} %{progname}(%{pid}) [%{severity}] %{msg}\n",
+      log4j_format: "%d %c(%t) [%p] %m%n",
+    },
+    production: {
+      log_format: "%{msg}\n",
+      log4j_format: "%m%n",
+    },
+    staging: {
+      log_format: "%{msg}\n",
+      log4j_format: "%m%n",
+    },
+  }
+
+  # Create a new {Configuration} object.
+  #
+  # @yield [config]  The new configuration object.
+  def initialize
+    @mixins = OrderedSet.new
+    @callbacks = []
+    mixin(DEFAULTS)
+  end
+
+  # Mixin a configuration snippet into the current section.
+  #
+  # @param [Hash, String] value  A hash to merge into the current
+  #                              configuration. If a string is given a filename
+  #                              is assumed and the given file is expected to
+  #                              contain a YAML hash.
+  # @return [void]
+  def mixin(value)
+    @mixins << value
+
+    if value.is_a?(String)
+      value = YAML.load(File.read(value))
+    end
+
+    return unless value
+
+    value = Section.from_hash(value)
+
+    deep_merge!(value[:generic]) if value.has_key?(:generic)
+
+    if value.has_key?(Env.to_sym)
+      deep_merge!(value[Env.to_sym])
+    else
+      deep_merge!(value)
+    end
+  end
+
+  # Reload all mixins.
+  #
+  # @return [void]
+  def reload!
+    clear
+
+    @mixins.each do |file|
+      mixin(file)
+    end
+
+    @callbacks.each do |callback|
+      callback.call(self)
+    end
+  end
+
+  # Register a callback for config mixins.
+  #
+  # @return [void]
+  def callback(&block)
+    @callbacks << block
+  end
+
+end

data/lib/liquid/environment.rb

@@ -0,0 +1,67 @@
+##
+# A simple convenience class to support multiple environments in which a
+# program can run (e.g. development, production, etc).
+#
+class Environment
+  attr_accessor :key
+
+  # Create a new Environment instance with the corresponding +key+ in the +ENV+
+  # hash.
+  #
+  # @param [String] key  The key in +ENV+ to contain the current program
+  #                      environment.
+  #
+  def initialize(key = "RACK_ENV")
+    @key = key
+  end
+
+  # Retreive the current environment mode.
+  #
+  # @return [String]  The current environment mode.
+  def mode
+    ENV[@key] || 'development'
+  rescue
+    'development'
+  end
+
+  # Retrieve the current environment mode and convert it to a symbol.
+  #
+  # @return [Symbol]  The current environment mode.
+  def to_sym
+    mode.to_sym
+  end
+
+  # Return true if the current environment is +production+.
+  def production?
+    to_sym == :production
+  end
+
+  alias :prod? :production?
+
+  # Return true if the current environment is +production+.
+  def staging?
+    to_sym == :staging
+  end
+
+  # Return true if the current environment is +development+.
+  def development?
+    to_sym == :development
+  end
+
+  alias :dev? :development?
+
+  # Return true if the current environment is +test+.
+  def test?
+    to_sym == :test
+  end
+
+  # Set the environment mode.
+  #
+  # @param [String]  The new environment mode.
+  def set(value)
+    ENV[@key] = value.to_s
+  end
+end
+
+# Global instance of {Environment}.
+Env = Environment.new

data/lib/liquid/ext/array.rb

@@ -0,0 +1,23 @@
+class Array
+
+  def pick(n=1)
+    Array.new(n) { self[Kernel::rand(size)-1] }
+  end
+
+  def pick_one
+    self[Kernel::rand(size)-1]
+  end
+
+  def to_h(&block)
+    Hash[*self.map { |v| [v, block.call(v)] }.flatten]
+  end
+
+  def / parts
+    inject([[]]) do |ary, x|
+      ary << [] if [*ary.last].nitems == length / parts
+      ary.last << x
+      ary
+    end
+  end
+
+end

data/lib/liquid/ext/enumerable.rb

@@ -0,0 +1,20 @@
+require 'active_support/core_ext/enumerable'
+
+module Enumerable
+  def mean
+    sum.to_f / length
+  end
+
+  def variance
+    m = mean
+    reduce(0) {|accum, item| accum + (item - m) ** 2}.to_f / (length - 1)
+  end
+
+  def stdev
+    Math.sqrt(variance)
+  end
+
+  def percentile(pc)
+    sort[(pc * length).ceil - 1]
+  end
+end

data/lib/liquid/ext/hash.rb

@@ -0,0 +1,31 @@
+##
+# Various Hash extensions.
+#
+class Hash
+
+  # Recursively merge +other_hash+ into +self+ and return the new hash.
+  def deep_merge(other_hash)
+    self.merge(other_hash) do |key, oldval, newval|
+      oldval = oldval.to_hash if oldval.respond_to?(:to_hash)
+      newval = newval.to_hash if newval.respond_to?(:to_hash)
+      oldval.is_a?(Hash) && newval.is_a?(Hash) ? oldval.deep_merge(newval) : newval
+    end
+  end
+
+  # Recursively merge and replace +other_hash+ into +self+.
+  def deep_merge!(other_hash)
+    replace(deep_merge(other_hash))
+  end
+
+  # accumulate existing keys from +other_hash+ into +self+.
+  def delta_merge!(other_hash)
+    other_hash.each do |k,v|
+      if self.has_key?(k)
+        self[k] += v
+      else
+        self[k] = v
+      end
+    end
+  end
+
+end

data/lib/liquid/ext/nil.rb

@@ -0,0 +1,5 @@
+class NilClass
+  def empty?
+    true
+  end
+end

data/lib/liquid/ext/object_space.rb

@@ -0,0 +1,49 @@
+module Memory
+  WORD_SIZE = 8
+  OBJ_SIZE = 40 # some are smaller
+  OBJ_OVERHEAD = WORD_SIZE + OBJ_SIZE
+
+  def self.size(obj)
+    return WORD_SIZE if obj.is_a?(Fixnum)
+
+    case obj
+    when String
+      obj.size
+    when Array
+      obj.size * WORD_SIZE
+    when Hash
+      obj.size * WORD_SIZE * 2
+    #when Enumerable
+    #  result = 0
+    #  obj.each do |ref|
+    #    result += WORD_SIZE
+    #  end
+    #  result
+    else
+      0
+    end + OBJ_OVERHEAD
+  rescue => e
+    puts "failed to get object size for #{obj.inspect}: #{e}"
+    return OBJ_OVERHEAD
+  end
+end
+
+module ObjectSpace
+  def self.memory_stats(*args)
+    stats = {}
+
+    self.each_object do |obj|
+      stats[obj.class] ||= []
+      stats[obj.class] << Memory.size(obj)
+    end
+
+    stats.map do |cls, sizes|
+      cnt = sizes.length
+      sum = sizes.reduce(:+)
+      avg = sum / cnt
+      [cls, [cnt, avg, sum]]
+    end.sort_by do |cls, sizes|
+      sizes[2]
+    end.reverse
+  end
+end

data/lib/liquid/ext/ordered_set.rb

@@ -0,0 +1,10 @@
+# http://stackoverflow.com/a/8451605/965088
+require 'set'
+require 'active_support/ordered_hash'
+
+class OrderedSet < Set
+  def initialize enum = nil, &block
+    @hash = ActiveSupport::OrderedHash.new
+    super
+  end
+end

data/lib/liquid/ext/signal.rb

@@ -0,0 +1,13 @@
+module Signal
+  def self.register_shutdown_handler(&block)
+    signals = %w(INT TERM)
+
+    # The signal QUIT is in use by the JVM itself
+    signals << 'QUIT' unless RUBY_PLATFORM == 'java'
+
+    signals.each do |sig|
+      old = trap(sig) {}
+      trap(sig) { block.call; old.call }
+    end
+  end
+end

data/lib/liquid/ext/string.rb

@@ -0,0 +1,3 @@
+class String
+  alias each each_line
+end

data/lib/liquid/ext/thread.rb

@@ -0,0 +1,17 @@
+# make default what should be default
+Thread.abort_on_exception = true
+
+class Thread
+
+  def self.name
+    Thread.current[:name] || Java::JavaLang::Thread.currentThread.getName
+  end
+
+  def self.name=(value)
+    Thread.current[:name] = value
+    if RUBY_PLATFORM == "java"
+      Java::JavaLang::Thread.currentThread.setName(value)
+    end
+  end
+
+end