psd 0.3.2

data/lib/psd/nodes/search.rb

@@ -0,0 +1,28 @@
+class PSD
+  class Node
+    module Search
+      # Searches the tree structure for a node at the given path. The path is
+      # defined by the layer/folder names. Because the PSD format does not
+      # require unique layer/folder names, we always return an array of all
+      # found nodes.
+      def children_at_path(path, opts={})
+        path = path.split('/').delete_if { |p| p == "" } unless path.is_a?(Array)
+
+        query = path.shift
+        matches = children.select do |c|
+          if opts[:case_sensitive]
+            c.name == query
+          else
+            c.name.downcase == query.downcase
+          end
+        end
+
+        if path.length == 0
+          return matches
+        else
+          return matches.map { |m| m.children_at_path(path, opts) }.flatten
+        end
+      end
+    end
+  end
+end

data/lib/psd/pascal_string.rb

@@ -0,0 +1,14 @@
+# Helper class that parses a pascal string, which is a
+# string that has it's length prepended to it.
+class PascalString < BinData::Record
+  uint8  :len,  value: lambda { data.length }
+  string :data, read_length: :len
+
+  def get
+    self.data
+  end
+
+  def set(v)
+    self.data = v
+  end
+end

data/lib/psd/path_record.rb

@@ -0,0 +1,180 @@
+class PSD
+  # Parses a vector path
+  class PathRecord
+    attr_accessor :layer
+
+    # Facade to make it easier to parse the path record.
+    def self.read(layer)
+      pr = PSD::PathRecord.new(layer.file)
+      pr.layer = layer
+      pr
+    end
+
+    # Reads the record type and begins parsing accordingly.
+    def initialize(file)
+      @file = file
+
+      @record_type = @file.read_short
+
+      case @record_type
+      when 0, 3 then read_path_record
+      when 1, 2, 4, 5 then read_bezier_point
+      when 7 then read_clipboard_record
+      when 8 then read_initial_fill
+      else @file.seek(24, IO::SEEK_CUR)
+      end
+    end
+
+    # Writes out the path to file.
+    def write(outfile)
+      outfile.write_short @record_type
+      case @record_type
+      when 0 then write_path_record(outfile)
+      when 3 then write_path_record(outfile)
+      when 1 then write_bezier_point(outfile)
+      when 2 then write_bezier_point(outfile)
+      when 4 then write_bezier_point(outfile)
+      when 5 then write_bezier_point(outfile)
+      when 7 then write_clipboard_record(outfile)
+      when 8 then write_initial_fill(outfile)
+      else outfile.seek(24, IO::SEEK_CUR)
+      end
+    end
+
+    # Exports the path record to an easier to work with hash.
+    def to_hash
+      case @record_type
+      when 0, 3
+        {
+          num_points: @num_points
+        }
+      when 1, 2, 4, 5
+        {
+          linked: @linked,
+          preceding: {
+            vert: @preceding_vert,
+            horiz: @preceding_horiz
+          },
+          anchor: {
+            vert: @anchor_vert,
+            horiz: @anchor_horiz
+          },
+          leaving: {
+            vert: @leaving_vert,
+            horiz: @leaving_horiz
+          }
+        }
+      when 7
+        {
+          clipboard: {
+            top: @clipboard_top,
+            left: @clipboard_left,
+            bottom: @clipboard_bottom,
+            right: @clipboard_right,
+            resolution: @clipboard_resolution
+          }
+        }
+      when 8
+        {
+          initial_fill: @initial_fill
+        }
+      else
+        {}
+      end.merge({ record_type: @record_type })
+    end
+
+    # Attempts to translate the path
+    def translate(x=0, y=0)
+      return unless is_bezier_point?
+
+      document_width, document_height = @layer.document_dimensions
+      translate_x_ratio = x.to_f / document_width.to_f
+      translate_y_ratio = y.to_f / document_height.to_f
+
+      @preceding_vert += translate_y_ratio
+      @preceding_horiz += translate_x_ratio
+      @anchor_vert += translate_y_ratio
+      @anchor_horiz += translate_x_ratio
+      @leaving_vert += translate_y_ratio
+      @leaving_horiz += translate_x_ratio
+    end
+
+    # Attempts to scale the path
+    def scale(xr, yr)
+      return unless is_bezier_point?
+
+      @preceding_vert *= yr
+      @preceding_horiz *= xr
+      @anchor_vert *= yr
+      @anchor_horiz *= xr
+      @leaving_vert *= yr
+      @leaving_horiz *= xr
+    end
+
+    # Is this record a bezier point?
+    def is_bezier_point?
+      [1,2,4,5].include? @record_type
+    end
+
+    private
+
+    def read_path_record
+      @num_points = @file.read_short
+      @file.seek(22, IO::SEEK_CUR)
+    end
+
+    def write_path_record(file)
+      file.write_short @num_points
+      file.seek(22, IO::SEEK_CUR)
+    end
+
+    def read_bezier_point
+      @linked = [1,4].include? @record_type
+
+      @preceding_vert = @file.read_path_number
+      @preceding_horiz = @file.read_path_number
+
+      @anchor_vert = @file.read_path_number
+      @anchor_horiz = @file.read_path_number
+
+      @leaving_vert = @file.read_path_number
+      @leaving_horiz = @file.read_path_number
+    end
+
+    def write_bezier_point(outfile)
+      outfile.write_path_number @preceding_vert
+      outfile.write_path_number @preceding_horiz
+      outfile.write_path_number @anchor_vert
+      outfile.write_path_number @anchor_horiz
+      outfile.write_path_number @leaving_vert
+      outfile.write_path_number @leaving_horiz
+    end
+
+    def read_clipboard_record
+      @clipboard_top = @file.read_path_number
+      @clipboard_left = @file.read_path_number
+      @clipboard_bottom = @file.read_path_number
+      @clipboard_right = @file.read_path_number
+      @clipboard_resolution = @file.read_path_number
+      @file.seek(4, IO::SEEK_CUR)
+    end
+
+    def write_clipboard_record(file)
+      [@clipboard_top, @clipboard_left, @clipboard_bottom,
+        @clipboard_right, @clipboard_resolution].each do |point|
+          file.write_path_number point
+      end
+      file.seek(4, IO::SEEK_CUR)
+    end
+
+    def read_initial_fill
+      @initial_fill = @file.read_short
+      @file.seek(22, IO::SEEK_CUR)
+    end
+
+    def write_initial_fill(file)
+      file.write_short @initial_fill
+      file.seek(22, IO::SEEK_CUR)
+    end
+  end
+end

data/lib/psd/resource.rb

@@ -0,0 +1,27 @@
+class PSD
+  # Definition for a single Resource record.
+  #
+  # Most of the resources are options/preferences set by the user
+  # or automatically by Photoshop.
+  class Resource < BinData::Record
+    endian  :big
+
+    string  :type, read_length: 4
+    uint16  :id
+    uint8   :name_len
+    stringz :name, read_length: :name_length
+    uint32  :res_size
+
+    skip    length: :resource_size
+
+    #---
+    # Really weird padding business
+    def name_length
+      Util.pad2(name_len + 1) - 1
+    end
+
+    def resource_size
+      Util.pad2(res_size)
+    end
+  end
+end

data/lib/psd/resources.rb

@@ -0,0 +1,47 @@
+class PSD
+  # Parses and reads all of the Resource records in the document.
+  class Resources
+    include Section
+
+    attr_reader :resources
+    alias :data :resources
+    
+    def initialize(file)
+      @file = file
+      @resources = []
+      @length = nil
+    end
+
+    # Parses each Resource and stores them.
+    def parse
+      start_section
+
+      n = length
+      start = @file.tell
+
+      while n > 0
+        pos = @file.tell
+        @resources << PSD::Resource.read(@file)
+        n -= @file.tell - pos
+      end
+
+      unless n == 0
+        @file.seek start + length
+      end
+
+      end_section
+      return @resources
+    end
+
+    def skip
+      @file.seek length, IO::SEEK_CUR
+    end
+
+    private
+
+    def length
+      return @length unless @length.nil?
+      @length = @file.read_int
+    end
+  end
+end

data/lib/psd/section.rb

@@ -0,0 +1,26 @@
+class PSD
+  # Helper that lets us track the beginning and ending locations
+  # of each section. This is for debug and error catching purposes,
+  # primarily.
+  module Section
+    attr_reader :section_start, :section_end
+
+    def start_section(section=:all)
+      @section_start = {} unless @section_start
+      @section_start[section] = @file.tell
+    end
+
+    def end_section(section=:all)
+      @section_end = {} unless @section_end
+      @section_end[section] = @file.tell
+    end
+
+    def start_of_section(section=:all)
+      @section_start[section]
+    end
+
+    def end_of_section(section=:all)
+      @section_end[section]
+    end
+  end
+end

data/lib/psd/util.rb

@@ -0,0 +1,17 @@
+class PSD
+  class Util
+    # Ensures value is a multiple of 2
+    def self.pad2(i)
+      ((i + 1) / 2) * 2
+    end
+
+    # Ensures value is a multiple of 4
+    def self.pad4(i)
+      i - (i.modulo(4)) + 3
+    end
+
+    def self.clamp(num, min, max)
+      [min, num, max].sort[1]
+    end
+  end
+end

data/lib/psd/version.rb

@@ -0,0 +1,3 @@
+class PSD
+  VERSION = "0.3.2"
+end

data/psd.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'psd/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "psd"
+  gem.version       = PSD::VERSION
+  gem.authors       = ["Ryan LeFevre", "Kelly Sutton"]
+  gem.email         = ["ryan@layervault.com", "kelly@layervault.com"]
+  gem.description   = %q{Parse Photoshop save files with ease}
+  gem.summary       = %q{General purpose library for parsing Photoshop save files}
+  gem.homepage      = "http://cosmos.layervault.com/psdrb.html"
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "bindata"
+  gem.add_dependency "chunky_png"
+  gem.add_dependency 'psd-enginedata'
+
+  gem.test_files = Dir.glob("spec/**/*")
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'guard'
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'rb-fsevent', '~> 0.9'
+end

data/spec/hierarchy_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe "Hierarchy" do
+  before(:each) do
+    @psd = PSD.new('spec/files/example.psd')
+  end
+
+  it "should parse tree" do
+    @psd.parse!
+    
+    tree = @psd.tree.to_hash
+    tree.should include :children
+    tree[:children].length.should == 3
+  end
+
+  describe "Ancestry" do
+    before(:each) do
+      @psd.parse!
+      @tree = @psd.tree
+    end
+
+    it "should provide tree traversal methods" do
+      @tree.respond_to?(:root).should be_true
+      @tree.respond_to?(:siblings).should be_true
+      @tree.respond_to?(:descendants).should be_true
+      @tree.respond_to?(:subtree).should be_true
+    end
+
+    it "should properly identify the root node" do
+      @tree.root?.should be_true
+      @tree.root.should == @tree
+      @tree.children.last.root.should == @tree
+    end
+
+    it "should retrieve all descendants of a node" do
+      @tree.descendants.size.should == 12
+      @tree.descendant_layers.size.should == 9
+      @tree.descendant_groups.size.should == 3
+      @tree.descendants.first.should_not == @tree
+    end
+
+    it "should retreive the entire subtree of a node" do
+      @tree.subtree.size.should == 13
+      @tree.subtree_layers.size.should == 9
+      @tree.subtree_groups.size.should == 3
+      @tree.subtree.first.should == @tree
+    end
+
+    it "should properly identify the existence of children" do
+      @tree.has_children?.should be_true
+      @tree.is_childless?.should be_false
+      @tree.descendant_layers.first.has_children?.should be_false
+      @tree.descendant_layers.first.is_childless?.should be_true
+    end
+
+    it "should retrieve all siblings of a node" do
+      @tree.children.first.siblings.should == @tree.children
+      @tree.children.first.siblings.should include @tree.children.first
+      @tree.children.first.has_siblings?.should be_true
+      @tree.children.first.is_only_child?.should be_false
+    end
+
+    it "should properly calculate node depth" do
+      @tree.depth.should == 0
+      @tree.descendant_layers.last.depth.should == 2
+      @tree.children.first.depth.should == 1
+    end
+
+    describe "Searching" do
+      it "should find a node given a path" do
+        @tree.children_at_path('Version A/Matte').is_a?(Array).should be_true
+        @tree.children_at_path('Version A/Matte').size.should == 1
+        @tree.children_at_path('Version A/Matte').first.is_a?(PSD::Node::Layer).should be_true
+      end
+
+      it "should ignore leading slashes" do
+        @tree.children_at_path('/Version A/Matte').size.should == 1
+      end
+
+      it "should return an empty array when a node is not found" do
+        @tree.children_at_path('LOLWUTOMGBBQSAUCE').is_a?(Array).should be_true
+        @tree.children_at_path('LOLWUTOMGBBQSAUCE').size.should == 0
+      end
+    end
+  end
+end