bench9000 0.1

data/vendor/psd.rb/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/vendor/psd.rb/circle.yml

@@ -0,0 +1,6 @@
+machine:
+  ruby:
+    version: 2.0.0-p195
+test:
+  override:
+    - rspec

data/vendor/psd.rb/examples/build_image.rb

@@ -0,0 +1,16 @@
+require 'benchmark'
+require 'pp'
+require 'psd'
+
+file = ARGV[0] || '/Users/ryanlefevre/LayerVault/Turtleworks/Directory Page.psd'
+
+results = Benchmark.measure "Image exporting" do
+  psd = PSD.new(file)
+  psd.parse!
+
+  comp = psd.layer_comps[1]
+  psd.tree.filter_by_comp(comp[:id]).save_as_png('./output.png')
+end
+
+puts Benchmark::CAPTION
+puts results.to_s

data/vendor/psd.rb/examples/export_image.rb

@@ -0,0 +1,12 @@
+require 'benchmark'
+require './lib/psd'
+
+file = ARGV[0] || 'examples/images/example.psd'
+
+results = Benchmark.measure "Image exporting" do
+  psd = PSD.new(file)
+  psd.image.save_as_png 'output.png'
+end
+
+puts Benchmark::CAPTION
+puts results.to_s

data/vendor/psd.rb/examples/export_layer_images.rb

@@ -0,0 +1,19 @@
+require 'fileutils'
+require 'benchmark'
+require './lib/psd'
+
+file = ARGV[0] || 'examples/images/example.psd'
+psd = PSD.new(file, parse_layer_images: true)
+
+results = Benchmark.measure "Layer image exporting" do
+  psd.parse!
+end
+
+psd.tree.descendant_layers.each do |layer|
+  path = layer.path.split('/')[0...-1].join('/')
+  FileUtils.mkdir_p("output/#{path}")
+  layer.image.save_as_png "output/#{layer.path}.png"
+end
+
+puts Benchmark::CAPTION
+puts results.to_s

data/vendor/psd.rb/examples/export_node.rb

@@ -0,0 +1,7 @@
+require './lib/psd'
+
+psd = PSD.new('examples/images/example.psd')
+psd.parse!
+
+
+psd.export_node psd.tree.children.last.children[1], "asset.psd"

data/vendor/psd.rb/examples/export_text_data.rb

@@ -0,0 +1,13 @@
+require './lib/psd'
+
+file = ARGV[0] || 'examples/images/example.psd'
+psd = PSD.new(file)
+psd.parse!
+
+outfile = './enginedata'
+psd.tree.descendant_layers.each do |l|
+  next unless l.layer.adjustments[:type]
+  File.write(outfile, l.layer.adjustments[:type].engine_data)
+  puts "Exported to #{outfile}"
+  exit
+end

data/vendor/psd.rb/examples/guides.rb

@@ -0,0 +1,17 @@
+require 'benchmark'
+require './lib/psd'
+
+require 'pp'
+
+psd = nil
+file = ARGV[0] || 'examples/images/guides.psd'
+results = Benchmark.measure "PSD parsing" do
+  psd = PSD.new(file)
+  psd.parse!
+end
+
+if psd.guides
+  psd.guides.each do |guide|
+    pp guide
+  end
+end

data/vendor/psd.rb/examples/layer_comps.rb

@@ -0,0 +1,20 @@
+require 'benchmark'
+require 'pp'
+require 'psd'
+
+file = ARGV[0] || 'examples/images/example.psd'
+
+results = Benchmark.measure "Image exporting" do
+  psd = PSD.new(file, parse_layer_images: true)
+  psd.parse!
+
+  psd.layer_comps.each do |comp|
+    puts "Saving #{comp[:name]} - #{comp[:id]}"
+    psd.tree
+      .filter_by_comp(comp[:id])
+      .save_as_png("./#{comp[:name]}.png")
+  end
+end
+
+puts Benchmark::CAPTION
+puts results.to_s

data/vendor/psd.rb/examples/parse.rb

@@ -0,0 +1,36 @@
+require 'benchmark'
+require './lib/psd'
+
+psd = nil
+file = ARGV[0] || 'examples/images/example.psd'
+results = Benchmark.measure "PSD parsing" do
+  psd = PSD.new(file)
+  psd.parse!
+end
+
+if psd.resources[:layer_comps]
+  puts "\nLayer Comps:\n===================="
+  puts psd.resources[:layer_comps].data.names
+end
+
+puts "\nVisible Layers:\n===================="
+psd.layers.each do |layer|
+  next if layer.folder? || layer.hidden?
+
+  puts "Name: #{layer.name}"
+  puts "Position: top = #{layer.top}, left = #{layer.left}"
+  puts "Size: width = #{layer.width}, height = #{layer.height}"
+  puts "Mask: width = #{layer.mask.width}, height = #{layer.mask.height}"
+  puts "Reference point: #{layer.reference_point.x}, #{layer.reference_point.y}"
+
+  puts ""
+end
+
+puts "\nPSD Info:\n===================="
+puts "#{psd.width}x#{psd.height} #{psd.header.mode_name}"
+puts "#{psd.resources.data.size} resources parsed"
+puts "#{psd.layers.size} layers, #{psd.folders.size} folders"
+
+puts "\nBenchmark Results (seconds):\n===================="
+puts " "*7 + Benchmark::CAPTION
+puts "parse: " + results.to_s

data/vendor/psd.rb/examples/path.rb

@@ -0,0 +1,7 @@
+require './lib/psd'
+require 'pp'
+
+psd = PSD.new('examples/images/example.psd')
+psd.parse!
+
+pp psd.tree.children_at_path("Version D/Version E/Version F").first.to_hash

data/vendor/psd.rb/examples/profile.rb

@@ -0,0 +1,15 @@
+require 'ruby-prof'
+require './lib/psd'
+
+
+
+file = ARGV[0] || 'examples/images/example.psd'
+psd = PSD.new(file, parse_image: true)
+
+result = RubyProf.profile do
+  psd.parse!
+end
+
+printer = RubyProf::GraphHtmlPrinter.new(result)
+printer.print(File.new("./profile.html", 'w'), min_percent: 2)
+`open profile.html`

data/vendor/psd.rb/examples/slices.rb

@@ -0,0 +1,17 @@
+require 'benchmark'
+require './lib/psd'
+
+require 'pp'
+
+psd = nil
+file = ARGV[0] || 'examples/images/example.psd'
+results = Benchmark.measure "PSD parsing" do
+  psd = PSD.new(file)
+  psd.parse!
+end
+
+if psd.resources[:slices]
+  psd.resources[:slices].data.to_a.each do |slice|
+    pp slice
+  end
+end

data/vendor/psd.rb/examples/tree.rb

@@ -0,0 +1,8 @@
+require './lib/psd'
+require 'pp'
+
+file = ARGV[0] || 'examples/images/example.psd'
+psd = PSD.new(file)
+psd.parse!
+
+pp psd.tree.to_hash

data/vendor/psd.rb/examples/unimplemented_info.rb

@@ -0,0 +1,9 @@
+require './lib/psd'
+require 'pp'
+
+file = ARGV[0] || 'examples/images/example.psd'
+psd = PSD.new(file)
+psd.parse!
+
+puts '-> Layer Info Keys'
+pp PSD.keys.uniq

data/vendor/psd.rb/lib/psd.rb

@@ -0,0 +1,173 @@
+require "bindata"
+require "psd/enginedata"
+require "chunky_png"
+
+require_relative 'psd/section'
+
+dir_root = File.dirname(File.absolute_path(__FILE__)) + '/psd'
+[
+  '/image_exports/*',
+  '/image_formats/*',
+  '/image_modes/*',
+  '/nodes/*',
+  '/layer_info/*',
+  '/layer/*',
+  '/**/*'
+].each do |path|
+  Dir.glob(dir_root + path) { |file| require file if File.file?(file) }
+end
+
+# A general purpose parser for Photoshop files. PSDs are broken up in to 4 logical sections:
+# the header, resources, the layer mask (including layers), and the preview image. We parse
+# each of these sections in order.
+class PSD
+  include Logger
+  include Helpers
+  include NodeExporting
+
+  attr_reader :file, :opts
+  alias :options :opts
+
+  # Opens the named file, parses it, and makes it available for reading. Then, closes it after you're finished.
+  # @param filename [String]  the name of the file to open
+  # @return [PSD] the {PSD} object if no block was given, otherwise the value of the block
+  def self.open(filename, opts={}, &block)
+    raise "Must supply a block. Otherwise, use PSD.new." unless block_given?
+
+    psd = PSD.new(filename, opts)
+    psd.parse!
+
+    if 0 == block.arity
+      psd.instance_eval(&block)
+    else
+      yield psd
+    end
+  ensure
+    psd.close if psd
+  end
+
+  # Create and store a reference to our PSD file
+  def initialize(file, opts={})
+    @file = PSD::File.new(file, 'rb')
+    @file.seek 0 # If the file was previously used and not closed
+
+    @opts = opts
+    @header = nil
+    @resources = nil
+    @layer_mask = nil
+    @parsed = false
+  end
+
+  # Close the PSD file
+  def close
+    file.close unless file.closed?
+  end
+
+  # There is a specific order that must be followed when parsing
+  # the PSD. Sections can be skipped if needed. This method will
+  # parse all sections of the PSD.
+  def parse!
+    header
+    resources
+    layer_mask
+    image
+    
+    @parsed = true
+
+    return true
+  end
+
+  # Has our PSD been parsed yet?
+  def parsed?
+    @parsed
+  end
+
+  # Get the Header, parsing it if needed.
+  def header
+    return @header if @header
+
+    @header = Header.read(@file)
+    PSD.logger.debug @header.inspect
+  end
+
+  # Get the Resources section, parsing if needed.
+  def resources
+    return @resources unless @resources.nil?
+
+    ensure_header
+
+    @resources = Resources.new(@file)
+    @resources.parse
+
+    return @resources
+  end
+
+  # Get the LayerMask section. Ensures the header and resources
+  # have been parsed first since they are required.
+  def layer_mask
+    ensure_header
+    ensure_resources
+
+    @layer_mask ||= LayerMask.new(@file, @header, @opts).parse
+  end
+
+  # Get the full size flattened preview Image.
+  def image
+    ensure_header
+    ensure_resources
+    ensure_layer_mask
+
+    @image ||= (
+      # The image is the last section in the file, so we don't have to
+      # bother with skipping over the bytes to read more data.
+      image = Image.new(@file, @header)
+      LazyExecute.new(image, @file)
+        .later(:parse)
+        .ignore(:width, :height)
+    )
+  end
+
+  # Export the current file to a new PSD. This may or may not work.
+  def export(file)
+    parse! unless parsed?
+
+    # Create our file for writing
+    outfile = File.open(file, 'w')
+
+    # Reset the file pointer
+    @file.seek 0
+    @header.write outfile
+    @file.seek @header.num_bytes, IO::SEEK_CUR
+
+    # Nothing in the header or resources we want to bother with changing
+    # right now. Write it straight to file.
+    outfile.write @file.read(@resources.end_of_section - @file.tell)
+
+    # Now, the changeable part. Layers and masks.
+    layer_mask.export(outfile)
+
+    # And the rest of the file (merged image data)
+    outfile.write @file.read
+    outfile.flush
+  end
+
+  private
+
+  def ensure_header
+    header # Header is always required
+  end
+
+  def ensure_resources
+    return unless @resources.nil?
+    
+    @resources = Resources.new(@file)
+    @resources.skip
+  end
+
+  def ensure_layer_mask
+    return unless @layer_mask.nil?
+
+    @layer_mask = LayerMask.new(@file, @header, @opts)
+    @layer_mask.skip
+  end
+end

data/vendor/psd.rb/lib/psd/blend_mode.rb

@@ -0,0 +1,80 @@
+class PSD
+  # Describes the blend mode for a single layer or folder.
+  class BlendMode < BinData::Record
+    endian  :big
+
+    string  :sig, read_length: 4
+    string  :blend_key, read_length: 4, trim_value: true
+    uint8   :opacity
+    uint8   :clipping
+    bit8    :flags
+    skip    length: 1
+
+    # All of the blend modes are stored in the PSD file with a specific key.
+    # This is the mapping of that key to its readable name.
+    BLEND_MODES = {
+      norm: 'normal',
+      dark: 'darken',
+      lite: 'lighten',
+      hue:  'hue',
+      sat:  'saturation',
+      colr: 'color',
+      lum:  'luminosity',
+      mul:  'multiply',
+      scrn: 'screen',
+      diss: 'dissolve',
+      over: 'overlay',
+      hLit: 'hard light',
+      sLit: 'soft light',
+      diff: 'difference',
+      smud: 'exclusion',
+      div:  'color dodge',
+      idiv: 'color burn',
+      lbrn: 'linear burn',
+      lddg: 'linear dodge',
+      vLit: 'vivid light',
+      lLit: 'linear light',
+      pLit: 'pin light',
+      hMix: 'hard mix',
+      pass: 'passthru',
+      dkCl: 'darker color',
+      lgCl: 'lighter color',
+      fsub: 'subtract',
+      fdiv: 'divide'
+    }
+
+    # Get the readable name for this blend mode.
+    def mode
+      BLEND_MODES[blend_key.strip.to_sym]
+    end
+
+    # Set the blend mode with the readable name.
+    def mode=(val)
+      blend_key = BLEND_MODES.invert[val.strip.downcase]
+    end
+
+    # Opacity is stored as an integer between 0-255. This converts the opacity
+    # to a percentage value to match the Photoshop interface.
+    def opacity_percentage
+      opacity * 100 / 255
+    end
+
+    def transparency_protected
+      flags & 0x01
+    end
+
+    # Is this layer/folder visible?
+    def visible
+      !((flags & (0x01 << 1)) > 0)
+    end
+
+    def obsolete
+      (flags & (0x01 << 2)) > 0
+    end
+
+    def pixel_data_irrelevant
+      return nil unless (flags & (0x01 << 3)) > 0
+      (flags & (0x01 << 4)) > 0
+    end
+  end
+end