obf 0.9.8.8 → 0.9.8.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2ed2e2f90f78fab2afac2c3d1f52af1c8b7345e7cb3d0fa6434832899b62a05
-  data.tar.gz: cd9e8521d222e51a9fe6ea760134465a93e2bb05b9c9ee03252bd57e986890ca
+  metadata.gz: 6de44b1031f93761c343d16237a52774bb7eac26115059362c67adbb7e29fcf9
+  data.tar.gz: c3f9bb83b70af873f954df14810ce63c7ef164eeb3b9fcf5c0766370432edfd5
 SHA512:
-  metadata.gz: 02ef108ce774799e4242d1818104d12ae2fcb9c725ef05218bc55b8784330adb458a2d89a1341a2cf7abdd90c61ce2d7374297155151271a9730777a1af5e195
-  data.tar.gz: 56c075245f5cb0421b556c2618ca2dbe81ffda55d199e0f73787cdc34c0df4c942ae1419379babbeafee64dd088a09ea38b4311423c00a24a50dfb3a9212a34f
+  metadata.gz: a59b8d5ad10d2d11aeea4d62c5877f66adba5ce1e5366c1d9db63c49d9a76a54f121d485a33b3f2043895b2520643d04167c723b57f8373953a8fad575afce93
+  data.tar.gz: 9e484cc271472db85ba86f2e5a78d6271b1168175bbdfc2b9d24c2f09bc8ff25403ff45a3424f0e1e6c17a8fb670783b63c105f39404ee324e8d19ad3b9164c9

data/lib/obf/external.rb

@@ -1,5 +1,6 @@
 module OBF::External
-  def self.to_obf(hash, dest_path, path_hash=nil)
+  def self.to_obf(hash, dest_path, path_hash=nil, to_include=nil)
+    to_include ||= {images: true, sounds: true}
     if hash['boards']
       old_hash = hash
       hash = old_hash['boards'][0]
@@ -17,6 +18,7 @@ module OBF::External
     res['background'] = hash['background']
     res['url'] = hash['url']
     res['data_url'] = hash['data_url']
+    OBF::Utils.log("compressing board #{res['name'] || res['id']}")
 
     res['default_locale'] = hash['default_locale'] if hash['default_locale']
     res['label_locale'] = hash['label_locale'] if hash['label_locale']
@@ -114,87 +116,114 @@ module OBF::External
       OBF::Utils.update_current_progress(idx.to_f / button_count.to_f)
     end
 
-    images.each do |original_image|
-      image = {
-        'id' => original_image['id'],
-        'width' => original_image['width'],
-        'height' => original_image['height'],
-        'license' => OBF::Utils.parse_license(original_image['license']),
-        'url' => original_image['url'],
-        'data' => original_image['data'],
-        'data_url' => original_image['data_url'],
-        'content_type' => original_image['content_type']
-      }
-      if !path_hash
-        image['data'] ||= OBF::Utils.image_base64(image['url']) if image['url']
-        if image['data'] && (!image['content_type'] || !image['width'] || !image['height'])
-          attrs = OBF::Utils.image_attrs(image['data'])
-          image['content_type'] ||= attrs['content_type']
-          image['width'] ||= attrs['width']
-          image['height'] ||= attrs['height']
+    if to_include[:images]
+      hydra = Typhoeus::Hydra.hydra
+      grabs = []
+      images.each do |img|
+        if path_hash && path_hash['images'] && path_hash['images'][img['id']]
+        elsif img['url'] && !img['data']
+          got_url = OBF::Utils.get_url(img['url'], true)
+          if got_url['request']
+            hydra.queue(got_url['request'])
+            grabs << {req: got_url['request'], img: img, res: got_url}
+          end
         end
-      else
-        if path_hash['images'] && path_hash['images'][image['id']]
-          image['path'] = path_hash['images'][image['id']]['path']
-          image['content_type'] ||= path_hash['images'][image['id']]['content_type']
-          image['width'] ||= path_hash['images'][image['id']]['width']
-          image['height'] ||= path_hash['images'][image['id']]['height']
+      end
+      hydra.run
+      grabs.each do |grab|
+          str = "data:" + grab[:res]['content_type']
+        str += ";base64," + Base64.strict_encode64(grab[:res]['data'])
+        grab[:img]['data'] = str
+        grab[:img]['content_type'] ||= grab[:res]['content_type']
+      end
+
+      images.each do |original_image|
+        image = {
+          'id' => original_image['id'],
+          'width' => original_image['width'],
+          'height' => original_image['height'],
+          'license' => OBF::Utils.parse_license(original_image['license']),
+          'url' => original_image['url'],
+          'data' => original_image['data'],
+          'data_url' => original_image['data_url'],
+          'content_type' => original_image['content_type']
+        }
+        if !path_hash
+          # not zipping
+          image['data'] ||= OBF::Utils.image_base64(image['url']) if image['url']
+          if image['data'] && (!image['content_type'] || !image['width'] || !image['height'])
+            attrs = OBF::Utils.image_attrs(image['data'])
+            image['content_type'] ||= attrs['content_type']
+            image['width'] ||= attrs['width']
+            image['height'] ||= attrs['height']
+          end
         else
-          image_fetch = OBF::Utils.image_raw(image['data'] || image['url'])
-          if image_fetch
-            if !image['content_type'] || !image['width'] || !image['height']
-              attrs = OBF::Utils.image_attrs(image_fetch['data'])
-              image['content_type'] ||= image_fetch['content_type'] || attrs['content_type']
-              image['width'] ||= attrs['width']
-              image['height'] ||= attrs['height']
+          # zipping, so needs to be downloaded and potentially re-used
+          if path_hash['images'] && path_hash['images'][image['id']]
+            image['path'] = path_hash['images'][image['id']]['path']
+            image['content_type'] ||= path_hash['images'][image['id']]['content_type']
+            image['width'] ||= path_hash['images'][image['id']]['width']
+            image['height'] ||= path_hash['images'][image['id']]['height']
+          else
+            image_fetch = OBF::Utils.image_raw(image['data'] || image['url'])
+            if image_fetch
+              if !image['content_type'] || !image['width'] || !image['height']
+                attrs = OBF::Utils.image_attrs(image_fetch['data'])
+                image['content_type'] ||= image_fetch['content_type'] || attrs['content_type']
+                image['width'] ||= attrs['width']
+                image['height'] ||= attrs['height']
+              end
+              zip_path = "images/image_#{image['id']}#{image_fetch['extension']}"
+              path_hash['images'] ||= {}
+              path_hash['images'][image['id']] = {
+                'path' => zip_path,
+                'content_type' => image['content_type'],
+                'width' => image['width'],
+                'height' => image['height']
+              }
+              path_hash['zip'].add(zip_path, image_fetch['data'])
+              image['path'] = zip_path
+              image.delete('data')
             end
-            zip_path = "images/image_#{image['id']}#{image_fetch['extension']}"
-            path_hash['images'] ||= {}
-            path_hash['images'][image['id']] = {
-              'path' => zip_path,
-              'content_type' => image['content_type'],
-              'width' => image['width'],
-              'height' => image['height']
-            }
-            path_hash['zip'].add(zip_path, image_fetch['data'])
-            image['path'] = zip_path
           end
         end
+        res['images'] << trim_empties(image)
       end
-      res['images'] << trim_empties(image)
     end
     
-    sounds.each do |original_sound|
-      sound = {
-        'id' => original_sound['id'],
-        'duration' => original_sound['duration'],
-        'license' => OBF::Utils.parse_license(original_sound['license']),
-        'url' => original_sound['url'],
-        'data' => original_sound['data'],
-        'data_url' => original_sound['data_url'],
-        'content_type' => original_sound['content_type']
-      }
-      if !path_hash
-        sound['data'] = OBF::Utils.sound_base64(sound['url']) if sound['url']
-      else
-        if path_hash['sounds'] && path_hash['sounds'][sound['id']]
-          sound['path'] = path_hash['sounds'][sound['id']]['path']
+    if to_include[:sounds]
+      sounds.each do |original_sound|
+        sound = {
+          'id' => original_sound['id'],
+          'duration' => original_sound['duration'],
+          'license' => OBF::Utils.parse_license(original_sound['license']),
+          'url' => original_sound['url'],
+          'data' => original_sound['data'],
+          'data_url' => original_sound['data_url'],
+          'content_type' => original_sound['content_type']
+        }
+        if !path_hash
+          sound['data'] = OBF::Utils.sound_base64(sound['url']) if sound['url']
         else
-          sound_fetch = OBF::Utils.sound_raw(sound['url'] || sound['data'])
-          if sound_fetch
-            zip_path = "sounds/sound_#{sound['id']}#{sound_fetch['extension']}"
-            path_hash['sounds'] ||= {}
-            path_hash['sounds'][sound['id']] = {
-              'path' => zip_path
-            }
-            path_hash['zip'].add(zip_path, sound_fetch['data'])
-            sound['path'] = zip_path
+          if path_hash['sounds'] && path_hash['sounds'][sound['id']]
+            sound['path'] = path_hash['sounds'][sound['id']]['path']
+          else
+            sound_fetch = OBF::Utils.sound_raw(sound['url'] || sound['data'])
+            if sound_fetch
+              zip_path = "sounds/sound_#{sound['id']}#{sound_fetch['extension']}"
+              path_hash['sounds'] ||= {}
+              path_hash['sounds'][sound['id']] = {
+                'path' => zip_path
+              }
+              path_hash['zip'].add(zip_path, sound_fetch['data'])
+              sound['path'] = zip_path
+            end
           end
+          sound['path'] = zip_path
         end
-        sound['path'] = zip_path
+        
+        res['sounds'] << trim_empties(sound)
       end
-      
-      res['sounds'] << trim_empties(sound)
     end
 
     res['grid'] = OBF::Utils.parse_grid(hash['grid']) # TODO: more robust parsing here
@@ -208,6 +237,7 @@ module OBF::External
     else
       File.open(dest_path, 'w') {|f| f.write(JSON.pretty_generate(res)) }
     end
+    OBF::Utils.log("  done compressing board #{res['name'] || res['id']}")
     return dest_path
   end
   
@@ -274,7 +304,7 @@ module OBF::External
         if b
           b['images'] = content['images'] || []
           b['sounds'] = content['sounds'] || []
-          to_obf(b, nil, paths)
+          to_obf(b, nil, paths, opts[:to_include])
         end
       end
       manifest = {
@@ -355,6 +385,7 @@ module OBF::External
     tmp_path = OBF::Utils.temp_path("stash")
     if opts['packet']
       OBF::Utils.as_progress_percent(0, 0.3) do
+        opts[:to_include] = {images: true}
         OBF::External.to_obz(board, tmp_path, opts)  
       end
       OBF::Utils.as_progress_percent(0.3, 1.0) do
@@ -362,7 +393,7 @@ module OBF::External
       end
     else
       OBF::Utils.as_progress_percent(0, 0.5) do
-        self.to_obf(board, tmp_path)  
+        self.to_obf(board, tmp_path, {images: true})  
       end
       OBF::Utils.as_progress_percent(0.5, 1.0) do
         OBF::OBF.to_pdf(tmp_path, dest_path, opts)

data/lib/obf/pdf.rb

@@ -190,21 +190,25 @@ module OBF::PDF
         grabs = []
         obj['buttons'].each do |btn|
           image = (obj['images_hash'] || {})[btn['image_id']]
-          if image && image['url'] && !image['data'] && !(image['path'] && optionns['zipper'])
+          if image && image['url'] && !image['data'] && !(image['path'] && options['zipper'])
             url = image['url']
-            uri = url.match(/\%/) ? url : URI.escape(url)
-            uri = OBF::Utils.sanitize_url(uri)
-            req = Typhoeus::Request.new(uri, followlocation: true)
-            hydra.queue(req)
-            grabs << {url: url, req: req, image: image, fill: btn['background_color'] ? OBF::Utils.fix_color(btn['background_color'], 'hex') : "ffffff"}
+            res = OBF::Utils.get_url(url, true)
+            if res['request']
+              hydra.queue(res['request'])
+              grabs << {url: url, req: res['request'], image: image, fill: btn['background_color'] ? OBF::Utils.fix_color(btn['background_color'], 'hex') : "ffffff"}
+            end
+          elsif image && image['data'] && !(image['path'] && options['zipper'])
+            grabs << {image: image, fill: btn['background_color'] ? OBF::Utils.fix_color(btn['background_color'], 'hex') : "ffffff"}
           end
         end
         hydra.run
         threads = []
         grabs.each do |grab|
-          grab[:image]['raw_data'] = grab[:req].response.body
+          if grab[:req]
+            grab[:image]['raw_data'] = grab[:req].response.body
+            grab[:image]['content_type'] ||= grab[:req].response.headers['Content-Type'] if grab[:req].response.headers['Content-Type']
+          end
           grab[:image]['threadable'] = true
-          grab[:image]['content_type'] = grab[:req].response.headers['Content-Type'] if grab[:req].response.headers['Content-Type']
           bg = 'white'
           if options['transparent_background'] || options['symbol_background'] == 'transparent'
             bg = "\##{grab[:fill]}"
@@ -212,10 +216,10 @@ module OBF::PDF
             bg = 'black'
           end
           res = OBF::Utils.save_image(grab[:image], options['zipper'], bg)
-          threads << res unless res.is_a?(String)
+          threads << res if res && !res.is_a?(String)
         end
         threads.each{|t| t.join }
-        grabs.each{|g| g[:image]['threadable'] = false }
+        grabs.each{|g| g[:image].delete('threadable') }
         OBF::Utils.log "  done with #{grabs.length} remote images!"
 
         obj['grid']['order'].each_with_index do |buttons, row|

data/lib/obf/utils.rb

@@ -1,7 +1,8 @@
 require 'cfpropertylist'
 module OBF::Utils
-  def self.get_url(url)
+  def self.get_url(url, hydra_wait=false)
     return nil unless url
+    res = {}
     content_type = nil
     data = nil
     if url.match(/^data:/)
@@ -10,10 +11,36 @@ module OBF::Utils
     else
       uri = url.match(/\%/) ? url : URI.escape(url)
       uri = self.sanitize_url(uri)
-      res = Typhoeus.get(uri, followlocation: true)
-      content_type = res.headers['Content-Type']
-      data = res.body
+      if hydra_wait
+        req = Typhoeus::Request.new(uri, followlocation: true)
+        req.on_complete do |response|
+          res.delete('request')
+          res['content_type'] = response.headers['Content-Type']
+          res['data'] = response.body
+          res['extension'] = extension_for(res['content_type'])
+        end
+        res['request'] = req
+      else
+        req = Typhoeus.get(uri, followlocation: true)
+        content_type = req.headers['Content-Type']
+        data = req.body
+      end
+    end
+    res['content_type'] = content_type
+    res['data'] = data
+    res['extension'] = extension_for(content_type)
+    if res['request']
+      if hydra_wait
+        # do nothing
+      else
+        res['request'].run
+        res.delete('request')
+      end
     end
+    res
+  end
+
+  def self.extension_for(content_type)
     type = MIME::Types[content_type]
     type = type && type[0]
     extension = ""
@@ -22,12 +49,7 @@ module OBF::Utils
     elsif type.respond_to?(:extensions)
       extension = ("." + type.extensions[0]) if type && type.extensions && type.extensions.length > 0
     end
-    res = {
-      'content_type' => content_type,
-      'data' => data,
-      'extension' => extension
-    }
-    res
+    extension
   end
 
   def self.sanitize_url(url)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: obf
 version: !ruby/object:Gem::Version
-  version: 0.9.8.8
+  version: 0.9.8.9
 platform: ruby
 authors:
 - Brian Whitmer