obf 0.1

data/lib/obf/obf.rb

@@ -0,0 +1,17 @@
+module OBF::OBF
+  def self.to_external(obf, opts)
+    OBF::External.from_obf(obf, opts)
+  end
+  
+  def self.from_external(board, dest_path)
+    OBF::External.to_obf(board, dest_path)
+  end
+  
+  def self.to_pdf(obf, dest_path)
+    OBF::PDF.from_obf(obf, dest_path)
+  end
+  
+  def self.to_png(obf, dest_path)
+    OBF::PNG.from_obf(obf, dest_path)
+  end
+end

data/lib/obf/obz.rb

@@ -0,0 +1,13 @@
+module OBF::OBZ
+  def self.to_external(obz, opts)
+    OBF::External.from_obz(obz, opts)
+  end
+  
+  def self.from_external(board, dest_path, opts)
+    OBF::External.to_obz(board, dest_path, opts)
+  end
+  
+  def self.to_pdf(obz, dest_path)
+    OBF::PDF.from_obz(obz, dest_path)
+  end
+end

data/lib/obf/pdf.rb

@@ -0,0 +1,196 @@
+module OBF::PDF
+  def self.from_obf(obf_json_or_path, dest_path, zipper=nil)
+    obj = obf_json_or_path
+    if obj.is_a?(String)
+      obj = OBF::Utils.parse_obf(File.read(obf_json_or_path))
+    else
+      obj = OBF::Utils.parse_obf(obf_json_or_path)
+    end
+    build_pdf(obj, dest_path, zipper)
+    return dest_path
+  end
+  
+  def self.build_pdf(obj, dest_path, zipper)
+    OBF::Utils.as_progress_percent(0, 1.0) do
+      # parse obf, draw as pdf
+      pdf = Prawn::Document.new(
+        :page_layout => :landscape, 
+        :page_size => [8.5*72, 11*72],
+        :info => {
+          :Title => obj['name']
+        }
+      )
+    
+    
+      if obj['boards']
+        obj['boards'].each_with_index do |board, idx|
+          pre = idx.to_f / obj['boards'].length.to_f
+          post = (idx + 1).to_f / obj['boards'].length.to_f
+          OBF::Utils.as_progress_percent(pre, post) do
+            pdf.start_new_page unless idx == 0
+            build_page(pdf, board, {'zipper' => zipper, 'pages' => obj['pages']})
+          end
+        end
+      else
+        build_page(pdf, obj, {})
+      end
+    
+      pdf.render_file(dest_path)
+    end
+  end
+  
+  def self.build_page(pdf, obj, options)
+    OBF::Utils.as_progress_percent(0, 1.0) do
+      doc_width = 11*72 - 72
+      doc_height = 8.5*72 - 72
+      default_radius = 3
+      text_height = 20
+    
+      # header
+      pdf.bounding_box([0, doc_height], :width => doc_width, :height => 100) do
+        pdf.line_width = 2
+        pdf.font_size 16
+        
+        pdf.fill_color "eeeeee"
+        pdf.stroke_color "888888"
+        pdf.fill_and_stroke_rounded_rectangle [0, 100], 100, 100, default_radius
+        pdf.fill_color "6D81D1"
+        pdf.fill_and_stroke_polygon([5, 50], [35, 85], [35, 70], [95, 70], [95, 30], [35, 30], [35, 15])
+        pdf.fill_color "ffffff"
+        pdf.text_box "Go Back", :at => [10, 90], :width => 80, :height => 80, :align => :center, :valign => :center, :overflow => :shrink_to_fit
+        pdf.fill_color "ffffff"
+        pdf.fill_and_stroke_rounded_rectangle [110, 100], (doc_width - 200 - 20), 100, default_radius
+        pdf.fill_color "DDDB54"
+        pdf.fill_and_stroke do
+          pdf.move_to 160, 50
+          pdf.line_to 190, 70
+          pdf.curve_to [190, 30], :bounds => [[100, 130], [100, -30]]
+          pdf.line_to 160, 50
+        end
+        pdf.fill_color "444444"
+        pdf.text_box "Say that sentence out loud for me", :at => [210, 90], :width => (doc_width - 200 - 120), :height => 80, :align => :left, :valign => :center, :overflow => :shrink_to_fit
+        pdf.fill_color "eeeeee"
+        pdf.fill_and_stroke_rounded_rectangle [(doc_width - 100), 100], 100, 100, default_radius
+        pdf.fill_color "aaaaaa"
+        pdf.fill_and_stroke_polygon([doc_width - 100 + 5, 50], [doc_width - 100 + 35, 85], [doc_width - 100 + 95, 85], [doc_width - 100 + 95, 15], [doc_width - 100 + 35, 15])
+        pdf.fill_color "ffffff"
+        pdf.text_box "Erase", :at => [(doc_width - 100 + 10), 90], :width => 80, :height => 80, :align => :center, :valign => :center, :overflow => :shrink_to_fit
+      end
+    
+      # board
+      pdf.font_size 12
+      padding = 10
+      grid_height = doc_height - 100 - text_height - (padding * 2)
+      grid_width = doc_width
+      if obj['grid'] && obj['grid']['rows'] > 0 && obj['grid']['columns'] > 0
+        button_height = (grid_height - (padding * (obj['grid']['rows'] - 1))) / obj['grid']['rows'].to_f
+        button_width = (grid_width - (padding * (obj['grid']['columns'] - 1))) / obj['grid']['columns'].to_f
+        obj['grid']['order'].each_with_index do |buttons, row|
+          buttons.each_with_index do |button_id, col|
+            button = obj['buttons'].detect{|b| b['id'] == button_id }
+            next unless button
+            x = (padding * col) + (col * button_width)
+            y = text_height + padding - (padding * row) + grid_height - (row * button_height)
+            pdf.bounding_box([x, y], :width => button_width, :height => button_height) do
+              fill = "ffffff"
+              border = "eeeeee"
+              if button['background_color']
+                fill = `node lib/tinycolor_convert.js "#{button['background_color']}"`.strip
+              end   
+              if button['border_color']
+                border = `node lib/tinycolor_convert.js "#{button['border_color']}"`.strip
+              end         
+              pdf.fill_color fill
+              pdf.stroke_color border
+              pdf.fill_and_stroke_rounded_rectangle [0, button_height], button_width, button_height, default_radius
+              pdf.bounding_box([5, button_height - 5], :width => button_width - 10, :height => button_height - text_height - 5) do
+                image = obj['images_hash'][button['image_id']]
+                image_local_path = image && OBF::Utils.save_image(image, options['zipper'])
+                if image_local_path && File.exist?(image_local_path)
+                  pdf.image image_local_path, :fit => [button_width - 10, button_height - text_height - 5], :position => :center, :vposition => :center
+                  File.unlink image_local_path
+                end
+              end
+              if options['pages'] && button['load_board']
+                page = options['pages'][button['load_board']['id']]
+                pdf.fill_color "ffffff"            
+                pdf.stroke_color "eeeeee"            
+                pdf.fill_and_stroke_rounded_rectangle [button_width - 25, button_height - 5], 20, text_height, 5
+                pdf.fill_color "000000"            
+                pdf.text_box page, :at => [button_width - 25, button_height - 5], :width => 20, :height => text_height, :align => :center, :valign => :center
+              end
+              
+              pdf.fill_color "000000"
+              pdf.text_box (button['label'] || button['vocalization']).to_s, :at => [0, text_height], :width => button_width, :height => text_height, :align => :center, :valign => :center, :overflow => :shrink_to_fit
+            end
+            index = col + (row * obj['grid']['columns'])
+            OBF::Utils.update_current_progress(index.to_f / (obj['grid']['rows'] * obj['grid']['columns']).to_f)
+          end
+        end
+      end
+    
+      # footer
+      pdf.fill_color "aaaaaa"
+      pdf.text_box "mycoughdrop.com", :at => [doc_width - 300, text_height], :width => 200, :height => text_height, :align => :right, :valign => :center, :overflow => :shrink_to_fit
+      pdf.fill_color "000000"
+      if options['pages']
+        pdf.text_box options['pages'][obj['id']], :at => [doc_width - 100, text_height], :width => 100, :height => text_height, :align => :right, :valign => :center, :overflow => :shrink_to_fit
+      end
+    end
+  end
+  
+  def self.from_obz(obz_path, dest_path)
+    OBF::Utils.load_zip(obz_path) do |zipper|
+      manifest = JSON.parse(zipper.read('manifest.json'))
+      root = manifest['root']
+      board = OBF::Utils.parse_obf(zipper.read(root))
+      board['path'] = root
+      unvisited_boards = [board]
+      visited_boards = []
+      while unvisited_boards.length > 0
+        board = unvisited_boards.shift
+        visited_boards << board
+        children = []
+        board['buttons'].each do |button|
+          if button['load_board']
+            children << button['load_board']
+            all_boards = visited_boards + unvisited_boards
+            if all_boards.none?{|b| b['id'] == button['load_board']['id'] || b['path'] == button['load_board']['path'] }
+              path = button['load_board']['path'] || manifest[button['load_board']['id']]
+              b = OBF::Utils.parse_obf(zipper.read(path))
+              b['path'] = path
+              unvisited_boards << b
+            end
+          end
+        end
+      end
+      
+      pages = {}
+      visited_boards.each_with_index do |board, idx|
+        pages[board['id']] = (idx + 1).to_s
+      end
+      
+      build_pdf({
+        'name' => 'Communication Board Set',
+        'boards' => visited_boards,
+        'pages' => pages
+      }, dest_path, zipper)
+    end
+    # parse obz, draw as pdf
+
+    # TODO: helper files included at the end for emergencies (eg. body parts)
+    
+    return dest_path
+  end
+  
+  def self.from_external(board, dest_path, full_set=false)
+    tmp_path = OBF::Utils.temp_path("stash")
+    from_obz(OBF::OBZ.from_external(board, full_set, tmp_path), dest_path)
+    File.unlink(tmp_path) if File.exist?(tmp_path)
+    dest_path
+  end
+  
+  def self.to_png(pdf, dest_path)
+    OBF::PNG.from_pdf(pdf, dest_path)
+  end
+end

data/lib/obf/png.rb

@@ -0,0 +1,22 @@
+module OBF::PNG
+  def self.from_pdf(pdf_path, dest_path, opts={})
+    resize = ""
+    resize = "-resize 600x321 -quality 100" if opts[:resize]
+    `convert -density 300 -crop 3160x1690+0+600 +repage #{resize} #{pdf_path} #{dest_path}`
+    dest_path
+  end
+  
+  def self.from_obf(obf, dest_path)
+    tmp_path = OBF::Utils.temp_path("stash")
+    self.from_pdf(OBF::OBF.to_pdf(obf, tmp_path), dest_path)
+    File.unlink(tmp_path) if File.exist?(tmp_path)
+    dest_path
+  end
+  
+  def self.from_external(board, dest_path)
+    tmp_path = OBF::Utils.temp_path("stash")
+    self.from_pdf(OBF::External.to_pdf(board, tmp_path), dest_path)
+    File.unlink(tmp_path) if File.exist?(tmp_path)
+    dest_path
+  end
+end

data/lib/obf/utils.rb

@@ -0,0 +1,265 @@
+module OBF::Utils
+#   def self.board_to_remote(board, user, file_type, include)
+#     OBF::Utils.update_current_progress(0.2, :converting_file)
+#     # TODO: key off just the last change id for the board(s) when building the
+#     # filename, return existing filename if it exists and isn't about to expire
+#     path = OBF::Utils.temp_path("stash")
+# 
+#     content_type = nil
+#     if file_type == 'obf'
+#       content_type = 'application/obf'
+#     elsif file_type == 'obz'
+#       content_type = 'application/obz'
+#     elsif file_type == 'pdf'
+#       content_type = 'application/pdf'
+#     else
+#       raise "Unrecognized conversion type: #{file_type}"
+#     end
+#     key = Security.sha512(board.id.to_s, 'board_id')
+#     filename = "board_" + board.current_revision + "." + file_type.to_s
+#     remote_path = "downloads/#{key}/#{filename}"
+#     url = Uploader.check_existing_upload(remote_path)
+#     return url if url
+#     OBF::Utils.update_current_progress(0.3, :converting_file)
+#     
+#     OBF::Utils.as_progress_percent(0.3, 0.8) do
+#       if file_type == 'obz'
+#         if include == 'all'
+#           OBF::CoughDrop.to_obz(board, path, {'user' => user})
+#         else
+#           OBF::CoughDrop.to_obz(board, path, {'user' => user})
+#         end
+#       elsif file_type == 'obf'
+#         OBF::CoughDrop.to_obf(board, path)
+#       elsif file_type == 'pdf'
+#         OBF::CoughDrop.to_pdf(board, path, {'user' => user, 'packet' => (include == 'all')})
+#       end
+#     end
+#     OBF::Utils.update_current_progress(0.9, :uploading_file)
+#     url = Uploader.remote_upload(remote_path, path, content_type)
+#     raise "File not uploaded" unless url
+#     File.unlink(path) if File.exist?(path)
+#     return url
+#   end
+  
+#   def self.remote_to_boards(user, url)
+#     result = []
+#     OBF::Utils.update_current_progress(0.1, :downloading_file)
+#     response = Typhoeus.get(url)
+#     file = Tempfile.new('stash')
+#     file.binmode
+#     file.write response.body
+#     file.close
+#     OBF::Utils.update_current_progress(0.2, :processing_file)
+#     OBF::Utils.as_progress_percent(0.2, 1.0) do
+#       if url.match(/\.obz$/) || response.headers['Content-Type'] == 'application/obz'
+#         boards = OBF::CoughDrop.from_obz(file.path, {'user' => user})
+#         result = boards
+#       elsif url.match(/\.obf$/) || response.headers['Content-Type'] == 'application/obf'
+#         board = OBF::CoughDrop.from_obf(file.path, {'user' => user})
+#         result = [board]
+#       else
+#         raise "Unrecognized file type: #{response.headers['Content-Type']}"
+#       end
+#       file.unlink
+#     end
+#     return result
+#   end
+  
+  def self.get_url(url)
+    return nil unless url
+    res = Typhoeus.get(URI.escape(url))
+    extension = ""
+    type = MIME::Types[res.headers['Content-Type']]
+    type = type && type[0]
+    extension = ("." + type.preferred_extension) if type && type.extensions && type.extensions.length > 0
+    {
+      'content_type' => res.headers['Content-Type'],
+      'data' => res.body,
+      'extension' => extension
+    }
+  end
+  
+  def self.image_raw(url)
+    image = get_url(url)
+    return nil unless image
+    image
+  end
+  
+  def self.image_base64(url)
+    image = get_url(url)
+    return nil unless image
+    str = "data:" + image['content_type']
+    str += ";base64," + Base64.strict_encode64(image['data'])
+    str
+  end
+  
+  def self.save_image(image, zipper=nil)
+    if image['data']
+      if !image['content_type']
+        image['content_type'] = image['data'].split(/;/)[0].split(/:/)[1]
+      end
+    elsif image['path'] && zipper
+      image['raw_data'] = zipper.read(image['path'])
+      if !image['content_type']
+        types = MIME::Types.type_for(image['path'])
+        image['content_type'] = types[0] && types[0].to_s
+      end
+    elsif image['url']
+      url_data = get_url(image['url'])
+      image['raw_data'] = url_data['data']
+      image['content_type'] = url_data['content_type']
+    elsif image['symbol']
+      # not supported
+    end
+    type = MIME::Types[image['content_type']]
+    type = type && type[0]
+    extension = type && ("." + type.extensions.first)
+    file = Tempfile.new(["image_stash", extension.to_s])
+    file.binmode
+    if image['data']
+      str = Base64.strict_decode64(image['data'].split(/\,/, 2)[1])
+      file.write str
+    elsif image['raw_data']
+      file.write image['raw_data']
+    else
+      raise "uh-oh"
+    end
+    file.close
+    `convert #{file.path} -density 1200 -resize 300x300 -background none -gravity center -extent 300x300 #{file.path}.png`
+    "#{file.path}.png"
+  end
+  
+  def self.sound_raw(url)
+    sound = get_url(url)
+    return nil unless sound
+    sound
+  end
+  
+  def self.sound_base64(url)
+    sound = get_url(url)
+    return nil unless sound
+    str = "data:" + sound['content_type']
+    str += ";base64," + Base64.strict_encode64(sound['data'])
+    str
+  end
+  
+  def self.obf_shell
+    {
+      'format' => 'open-board-0.1',
+      'license' => {'type' => 'private'},
+      'buttons' => [],
+      'grid' => {
+        'rows' => 0,
+        'columns' => 0,
+        'order' => [[]]
+      },
+      'images' => [],
+      'sounds' => []
+    }
+  end
+  
+  def self.parse_obf(obj)
+    json = obj
+    if obj.is_a?(String)
+      json = JSON.parse(obj)
+    end
+    ['images', 'sounds', 'buttons'].each do |key|
+      json["#{key}_hash"] = json[key]
+      if json[key].is_a?(Array)
+        hash = {}
+        json[key].each do |item|
+          hash[item['id']] = item
+        end
+        json["#{key}_hash"] = hash
+      else
+        array = []
+        json["#{key}_hash"].each do |id, item|
+          item['id'] ||= id
+          array << item
+        end
+        json[key] = array
+      end
+    end
+    json
+  end
+  
+  def self.parse_license(pre_license)
+    pre_license = {} unless pre_license.is_a?(Hash)
+    license = {}
+    ['type', 'copyright_notice_url', 'source_url', 'author_name', 'author_url', 'author_email', 'uneditable'].each do |attr|
+      license[attr] = pre_license[attr] if pre_license[attr] != nil
+    end
+    license['type'] ||= 'private'
+    license['copyright_notice_url'] ||= license['copyright_notice_link'] if license.key?('copyright_notice_link')
+    license['source_url'] ||= license['source_link'] if license.key?('source_link')
+    license['author_url'] ||= license['author_link'] if license.key?('author_link')
+    license
+  end
+  
+  def self.parse_grid(pre_grid)
+    pre_grid ||= {}
+    grid = {
+      'rows' => pre_grid['rows'] || 1,
+      'columns' => pre_grid['columns'] || 1,
+      'order' => pre_grid['order'] || [[nil]]
+    }
+    # TODO: parse order better
+    grid
+  end
+  
+  def self.temp_path(*args)
+    file = Tempfile.new(*args)
+    res = file.path
+    file.unlink
+    res
+  end
+  
+  class Zipper
+    def initialize(zipfile)
+      @zipfile = zipfile
+    end
+    
+    def add(path, contents)
+      @zipfile.get_output_stream(path) {|os| os.write contents }
+    end
+    
+    def read(path)
+      entry = @zipfile.glob(path).first
+      entry ? entry.get_input_stream.read : nil
+    end
+  end
+  
+  def self.load_zip(path, &block)
+    require 'zip'
+
+    Zip::File.open(path) do |zipfile|
+      block.call(Zipper.new(zipfile))
+    end
+  end
+  
+  def self.build_zip(dest_path=nil, &block)
+    require 'zip'
+    
+    if !dest_path
+      dest_path = OBF::Utils.temp_path(['archive', '.obz'])
+    end
+    Zip::File.open(dest_path, Zip::File::CREATE) do |zipfile|
+      block.call(Zipper.new(zipfile))
+    end
+  end
+  
+  def self.update_current_progress(*args)
+    if Object.const_defined?('Progress')
+      Progress.update_current_progress(*args)
+    end
+  end
+  
+  def self.as_progress_percent(a, b, &block)
+    if Object.const_defined?('Progress')
+      Progress.as_percent(a, b, &block)
+    else
+      block.call
+    end
+  end
+end