iron_worker_ng 0.3.8 → 0.3.9

data/VERSION

@@ -1 +1 @@
-0.3.8
+0.3.9

data/lib/iron_worker_ng/code/ruby.rb

@@ -24,6 +24,151 @@ module IronWorkerNG
           runner.write <<RUNNER
 # iron_worker_ng-#{IronWorkerNG.version}
 
+# https://github.com/intridea/hashie/ 6d21c6868512603e77a340827ec91ecd3bcef078 START
+
+module Hashie
+  module Extensions
+    # The MergeInitializer is a super-simple mixin that allows
+    # you to initialize a subclass of Hash with another Hash
+    # to give you faster startup time for Hash subclasses. Note
+    # that you can still provide a default value as a second
+    # argument to the initializer.
+    #
+    # @example
+    #   class MyHash < Hash
+    #     include Hashie::Extensions::MergeInitializer
+    #   end
+    #
+    #   h = MyHash.new(:abc => 'def')
+    #   h[:abc] # => 'def'
+    #
+    module MergeInitializer
+      def initialize(hash = {}, default = nil, &block)
+        default ? super(default) : super(&block)
+        update(hash)
+      end
+    end
+  end
+end
+
+module Hashie
+  module Extensions
+    # IndifferentAccess gives you the ability to not care
+    # whether your hash has string or symbol keys. Made famous
+    # in Rails for accessing query and POST parameters, this
+    # is a handy tool for making sure your hash has maximum
+    # utility.
+    #
+    # One unique feature of this mixin is that it will recursively
+    # inject itself into sub-hash instances without modifying
+    # the actual class of the sub-hash.
+    #
+    # @example
+    #   class MyHash < Hash
+    #     include Hashie::Extensions::MergeInitializer
+    #     include Hashie::Extensions::IndifferentAccess
+    #   end
+    #
+    #   h = MyHash.new(:foo => 'bar', 'baz' => 'blip')
+    #   h['foo'] # => 'bar'
+    #   h[:foo]  # => 'bar'
+    #   h[:baz]  # => 'blip'
+    #   h['baz'] # => 'blip'
+    #
+    module IndifferentAccess
+      def self.included(base)
+        base.class_eval do
+          alias_method :regular_writer, :[]=
+          alias_method :[]=, :indifferent_writer
+          %w(default update fetch delete key? values_at).each do |m|
+            alias_method "regular_\#{m}", m
+            alias_method m, "indifferent_\#{m}"
+          end
+        end
+      end
+
+      # This will inject indifferent access into an instance of
+      # a hash without modifying the actual class. This is what
+      # allows IndifferentAccess to spread to sub-hashes.
+      def self.inject!(hash)
+        (class << hash; self; end).send :include, Hashie::Extensions::IndifferentAccess
+        hash.convert!
+      end
+
+      # Injects indifferent access into a duplicate of the hash
+      # provided. See #inject!
+      def self.inject(hash)
+        inject!(hash.dup)
+      end
+
+      def convert_key(key)
+        key.to_s
+      end
+
+      # Iterates through the keys and values, reconverting them to
+      # their proper indifferent state. Used when IndifferentAccess
+      # is injecting itself into member hashes.
+      def convert!
+        keys.each do |k|
+          regular_writer convert_key(k), convert_value(self.regular_delete(k))
+        end
+        self
+      end
+
+      def convert_value(value)
+        if hash_lacking_indifference?(value)
+          Hashie::Extensions::IndifferentAccess.inject(value.dup)
+        elsif value.is_a?(::Array)
+          value.dup.replace(value.map { |e| convert_value(e) })
+        else
+          value
+        end
+      end
+      
+      def indifferent_default(key = nil)
+        return self[convert_key(key)] if key?(key)
+        regular_default(key)
+      end
+
+      def indifferent_update(other_hash)
+        return regular_update(other_hash) if hash_with_indifference?(other_hash)
+        other_hash.each_pair do |k,v|
+          self[k] = v
+        end
+      end
+      
+      def indifferent_writer(key, value);  regular_writer convert_key(key), convert_value(value) end
+      def indifferent_fetch(key, *args);   regular_fetch  convert_key(key), *args                end
+      def indifferent_delete(key);         regular_delete convert_key(key)                       end
+      def indifferent_key?(key);           regular_key?   convert_key(key)                       end
+      def indifferent_values_at(*indices); indices.map{|i| self[i] }                             end
+
+      def indifferent_access?; true end
+      
+      protected
+
+      def hash_lacking_indifference?(other)
+        other.is_a?(::Hash) &&
+        !(other.respond_to?(:indifferent_access?) &&
+          other.indifferent_access?)
+      end
+
+      def hash_with_indifference?(other)
+        other.is_a?(::Hash) &&
+        other.respond_to?(:indifferent_access?) &&
+        other.indifferent_access?
+      end
+    end
+  end
+end
+
+# https://github.com/intridea/hashie/ 6d21c6868512603e77a340827ec91ecd3bcef078 END
+
+class IronWorkerNGHash < Hash
+  include Hashie::Extensions::MergeInitializer
+  include Hashie::Extensions::IndifferentAccess
+end
+
 root = nil
 payload_file = nil
 task_id = nil
@@ -45,16 +190,13 @@ require 'json'
 
 @payload = File.read(payload_file)
 
-@params = {}
+params = {}
 begin
-  @params = JSON.parse(@payload)
+  params = JSON.parse(@payload)
 rescue
 end
 
-keys = @params.keys
-keys.each do |key|
-  @params[key.to_sym] = @params[key]
-end
+@params = IronWorkerNGHash.new(params)
 
 def payload
   @payload

data/lib/iron_worker_ng/feature/ruby/merge_gem.rb

@@ -42,9 +42,9 @@ module IronWorkerNG
             if @spec.extensions.length == 0 || IronWorkerNG::Feature::Ruby::MergeGem.merge_binary?
               IronWorkerNG::Logger.debug "Bundling ruby gem with name='#{@spec.name}' and version='#{@spec.version}'"
 
-              zip.add('gems/' + @spec.full_name, gem_path)
+              zip.add('__gems__/' + @spec.full_name, gem_path)
               Dir.glob(gem_path + '/**/**') do |path|
-                zip.add('gems/' + @spec.full_name + path[gem_path.length .. -1], path)
+                zip.add('__gems__/' + @spec.full_name + path[gem_path.length .. -1], path)
               end
             else
               IronWorkerNG::Logger.warn "Skipping ruby gem with name='#{@spec.name}' and version='#{@spec.version}' as it contains native extensions"
@@ -53,7 +53,7 @@ module IronWorkerNG
 
           def code_for_gempath
             if @spec.extensions.length == 0 || IronWorkerNG::Feature::Ruby::MergeGem.merge_binary?
-              '$:.unshift("#{root}/gems/' + @spec.full_name + '/lib")'
+              '$:.unshift("#{root}/__gems__/' + @spec.full_name + '/lib")'
             else
               '# native gem ' + @spec.full_name
             end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iron_worker_ng
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.3.9
   prerelease: 
 platform: ruby
 authors:
@@ -156,7 +156,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -81500049
+      hash: -543812495
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: