bench9000 0.1

data/vendor/psd.rb/lib/psd/resources/slices.rb

@@ -0,0 +1,132 @@
+class PSD
+  class Resource
+    class Section
+      class Slices < Section
+        attr_reader :data, :version
+
+        def self.id; 1050; end
+        def self.name; :slices; end
+
+        def parse
+          @version = @file.read_int
+
+          case @version
+          when 6 then parse_legacy
+          when 7, 8 then
+            descriptor_version = @file.read_int
+            @data = Descriptor.new(@file).parse
+          end
+
+          normalize_data!
+
+          @resource.data = self
+        end
+
+        def to_a
+          return [] if @data.nil?
+          @data[:slices]
+        end
+
+        private
+
+        def parse_legacy
+          @data = {}
+
+          @data[:bounds] = {}.tap do |bounds|
+            bounds[:top] = @file.read_int
+            bounds[:left] = @file.read_int
+            bounds[:bottom] = @file.read_int
+            bounds[:right] = @file.read_int
+          end
+
+          @data[:name] = @file.read_unicode_string
+
+          @data[:slices] = []
+          slices_count = @file.read_int
+          slices_count.times do
+            @data[:slices] << {}.tap do |slice|
+              slice[:id] = @file.read_int
+              slice[:group_id] = @file.read_int
+              slice[:origin] = @file.read_int
+
+              slice[:associated_layer_id] = (slice[:origin] == 1 ? @file.read_int : nil)
+
+              slice[:name] = @file.read_unicode_string
+              slice[:type] = @file.read_int
+
+              slice[:bounds] = {}.tap do |bounds|
+                bounds[:left] = @file.read_int
+                bounds[:top] = @file.read_int
+                bounds[:right] = @file.read_int
+                bounds[:bottom] = @file.read_int
+              end
+
+              slice[:url] = @file.read_unicode_string
+              slice[:target] = @file.read_unicode_string
+              slice[:message] = @file.read_unicode_string
+              slice[:alt] = @file.read_unicode_string
+
+              slice[:cell_text_is_html] = @file.read_boolean
+              slice[:cell_text] = @file.read_unicode_string
+
+              slice[:horizontal_alignment] = @file.read_int
+              slice[:vertical_alignment] = @file.read_int
+
+              a, r, g, b = 4.times.map { @file.read_byte }
+              slice[:color] = ChunkyPNG::Color.rgba(r, g, b, a)
+            end
+          end
+        end
+
+        # Normalizes the data between version 6 and versions 7/8 to make it easier
+        # to deal with the discrepancies. We use version 6 as the base.
+        def normalize_data!
+          return if @version == 6
+          data = {}
+          data[:bounds] = {
+            top: @data['bounds']['Top '],
+            left: @data['bounds']['Left'],
+            bottom: @data['bounds']['Btom'],
+            right: @data['bounds']['Rght']
+          }
+
+          data[:name] = @data['baseName']
+
+          data[:slices] = @data['slices'].map do |slice|
+            {
+              id: slice['sliceID'],
+              group_id: slice['groupID'],
+              origin: slice['origin'],
+              associated_layer_id: nil,
+              name: '',
+              type: slice['Type'],
+              bounds: {
+                left: slice['bounds']['Left'],
+                top: slice['bounds']['Top '],
+                right: slice['bounds']['Rght'],
+                bottom: slice['bounds']['Btom']
+              },
+              url: slice['url'],
+              target: '',
+              message: slice['Msge'],
+              alt: slice['altTag'],
+              cell_text_is_html: slice['cellTextIsHTML'],
+              cell_text: slice['cellText'],
+              horizontal_alignment: slice['horzAlign'],
+              vertical_alignment: slice['vertAlign'],
+              color: nil,
+              outset: {
+                top: slice['topOutset'],
+                left: slice['leftOutset'],
+                bottom: slice['bottomOutset'],
+                right: slice['rightOutset']
+              }
+            }
+          end
+
+          @data = data
+        end
+      end
+    end
+  end
+end

data/vendor/psd.rb/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/vendor/psd.rb/lib/psd/util.rb

@@ -0,0 +1,18 @@
+class PSD
+  module Util
+    extend self
+    
+    def pad2(i)
+      (i + 1) & ~0x01
+    end
+
+    # Ensures value is a multiple of 4
+    def pad4(i)
+      ((i + 4) & ~0x03) - 1
+    end
+
+    def clamp(num, min, max)
+      [min, num, max].sort[1]
+    end
+  end
+end

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

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

data/vendor/psd.rb/psd.gemspec

@@ -0,0 +1,32 @@
+# -*- 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 PSD files with ease}
+  gem.summary       = %q{General purpose library for parsing Photoshop files}
+  gem.homepage      = "http://cosmos.layervault.com/psdrb.html"
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($/).delete_if { |f| f.include?('examples/') }
+  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 'rake'
+  gem.add_dependency 'bindata'
+  gem.add_dependency 'psd-enginedata', '~> 1.0'
+
+  gem.add_dependency 'chunky_png'
+
+  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/vendor/psd.rb/spec/guides_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe 'Guides' do
+  describe "Handle file with slice properly" do
+    it "should successfully parse the PSD file that has guides" do
+      psd = PSD.new('spec/files/guides.psd')
+      psd.parse!
+
+      # File should parse
+      expect(psd).to be_parsed
+
+      # Guides should not be nil
+      expect(psd.resources[:guides]).to_not be_nil
+
+      # Each guide should have a position and direction
+      psd.resources[:guides].data.to_a.each do |guide|
+        expect(guide).to_not be_nil
+        expect(guide[:location]).to_not be_nil
+        expect(guide[:direction]).to_not be_nil
+      end
+    end
+  end
+
+  describe "Handle file without guides properly" do
+    it "should successfully parse a PSD file which does not have guides" do
+      psd = PSD.new('spec/files/simplest.psd')
+      psd.parse!
+
+      expect(psd).to be_parsed
+
+      expect(psd.resources[:guides].data.to_a.size).to be 0
+    end
+  end
+end

data/vendor/psd.rb/spec/hierarchy_spec.rb

@@ -0,0 +1,152 @@
+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
+    expect(tree).to include :children
+    expect(tree[:children].length).to eq(3)
+  end
+
+  describe "Ancestry" do
+    before(:each) do
+      @psd.parse!
+      @tree = @psd.tree
+    end
+
+    it "should provide tree traversal methods" do
+      expect(@tree).to respond_to(:root)
+      expect(@tree).to respond_to(:siblings)
+      expect(@tree).to respond_to(:descendants)
+      expect(@tree).to respond_to(:subtree)
+    end
+
+    it "should properly identify the root node" do
+      expect(@tree.root?).to be true
+      expect(@tree.root).to be @tree
+      expect(@tree.children.last.root).to be @tree
+    end
+
+    it "should retrieve all descendants of a node" do
+      expect(@tree.descendants.size).to eq(12)
+      expect(@tree.descendant_layers.size).to eq(9)
+      expect(@tree.descendant_groups.size).to eq(3)
+      expect(@tree.descendants.first).not_to be @tree
+    end
+
+    it "should retreive the entire subtree of a node" do
+      expect(@tree.subtree.size).to eq(13)
+      expect(@tree.subtree_layers.size).to eq(9)
+      expect(@tree.subtree_groups.size).to eq(3)
+      expect(@tree.subtree.first).to be @tree
+    end
+
+    it "should properly identify the existence of children" do
+      expect(@tree).to have_children
+      expect(@tree).to_not be_childless
+      expect(@tree.descendant_layers.first).to_not have_children
+      expect(@tree.descendant_layers.first).to be_childless
+    end
+
+    it "should retrieve all siblings of a node" do
+      expect(@tree.children.first.siblings).to be @tree.children
+      expect(@tree.children.first.siblings).to include @tree.children.first
+      expect(@tree.children.first).to have_siblings
+      expect(@tree.children.first).to_not be_only_child
+    end
+
+    it "should properly calculate node depth" do
+      expect(@tree.depth).to eq(0)
+      expect(@tree.descendant_layers.last.depth).to eq(2)
+      expect(@tree.children.first.depth).to eq(1)
+    end
+
+    it "should be able to generate a path to a node" do
+      node = @tree.children_at_path('Version A/Matte').first
+      expect(node.path).to eq('Version A/Matte')
+    end
+
+    describe "Searching" do
+      it "should find a node given a path" do
+        expect(@tree.children_at_path('Version A/Matte')).to be_an_instance_of(Array)
+        expect(@tree.children_at_path('Version A/Matte').size).to eq(1)
+        expect(@tree.children_at_path('Version A/Matte').first).to be_an_instance_of(PSD::Node::Layer)
+      end
+
+      it "should ignore leading slashes" do
+        expect(@tree.children_at_path('/Version A/Matte').size).to eq(1)
+      end
+
+      it "should return an empty array when a node is not found" do
+        expect(@tree.children_at_path('NOPE')).to be_an_instance_of(Array)
+        expect(@tree.children_at_path('NOPE').size).to eq(0)
+      end
+
+      it "should throw an error if filtering by a non-existant layer comp" do
+        expect { @tree.filter_by_comp('WAT') }.to raise_error("Layer comp not found")
+      end
+
+      it "should correctly set visibility when filtering by layer comp" do
+        tree = @tree.filter_by_comp('Version A')
+        expect(tree).to be_an_instance_of(PSD::Node::Root)
+        expect(tree.children.size).to eq(3)
+        expect(tree.children_at_path('Version A').first).to be_visible
+        expect(tree.children_at_path('Version B').first).to_not be_visible
+      end
+
+      it "should return a new tree when filtering by layer comps" do
+        tree = @tree.filter_by_comp('Version A')
+        expect(tree).to_not eq(@tree)
+        expect(@tree.children.size).to eq(3)
+      end
+    end
+  end
+
+  # https://github.com/layervault/psd.rb/pull/54
+  describe "Size Calculation" do
+    before(:each) do
+      @psd = PSD.new('spec/files/empty-layer.psd')
+      @psd.parse!
+    end
+
+    it 'should correctly identify empty nodes' do
+      expect(@psd.tree.children_at_path('group/empty layer').first).to be_empty
+      expect(@psd.tree.children[0]).to_not be_empty
+    end
+
+    it "should correctly calculate the size of a group" do
+      expect(@psd.tree.children[0].width).to eq 100
+      expect(@psd.tree.children[0].height).to eq 100
+      expect(@psd.tree.children[0].left).to eq 450
+      expect(@psd.tree.children[0].top).to eq 450
+    end
+  end
+  
+  describe "Size Calculation With Empty Layer in Subgroups" do
+    before(:each) do
+      @psd = PSD.new('spec/files/empty-layer-subgroups.psd')
+      @psd.parse!
+    end
+
+    it 'should correctly identify empty nodes' do
+      expect(@psd.tree.children_at_path('group/not empty').first).to_not be_empty
+      expect(@psd.tree.children_at_path('group/Group 2').first).to be_empty
+      expect(@psd.tree.children_at_path('group/Group 2/Group 1').first).to be_empty
+      expect(@psd.tree.children_at_path('group/Group 2/subgroup 1/subgroup 2').first).to be_empty
+      expect(@psd.tree.children_at_path('group/Group 2/subgroup 1/subgroup 2/empty layer').first).to be_empty
+      expect(@psd.tree.children[0]).to_not be_empty
+    end
+
+    it "should correctly calculate the size of a group" do
+      expect(@psd.tree.children[0].width).to eq 264
+      expect(@psd.tree.children[0].height).to eq 198
+      expect(@psd.tree.children[0].left).to eq 448
+      expect(@psd.tree.children[0].top).to eq 356
+    end
+  end  
+end

data/vendor/psd.rb/spec/image_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe 'Image Exporting' do
+  let!(:psd) { PSD.new('spec/files/pixel.psd') }
+
+  describe "the full preview image" do
+    it "should successfully parse the image data" do
+      psd.parse!
+      expect(psd).to be_parsed
+      expect(psd.image).to_not be_nil
+      expect(psd.image.width).to eq(1)
+      expect(psd.image.height).to eq(1)
+      expect(psd.image.pixel_data).to eq([ChunkyPNG::Color.rgba(0, 100, 200, 255)])
+    end
+
+    it "should be able to skip to the image" do
+      expect(psd).to_not be_parsed
+      expect(psd.image.width).to eq(1)
+      expect(psd.image.height).to eq(1)
+      expect(psd.image.pixel_data).to eq([ChunkyPNG::Color.rgba(0, 100, 200, 255)])
+    end
+
+    describe "as PNG" do
+      it "should produce a valid PNG object" do
+        expect(psd.image.to_png).to be_an_instance_of(ChunkyPNG::Canvas)
+
+        expect(psd.image.to_png.width).to eq(1)
+        expect(psd.image.to_png.height).to eq(1)
+        expect(
+          ChunkyPNG::Color.to_truecolor_alpha_bytes(psd.image.to_png[0,0])
+        ).to eq([0, 100, 200, 255])
+      end
+    end
+  end
+
+  describe "Renderer" do
+    before(:each) do
+      psd.parse!
+    end
+
+    it "should be available via any tree node" do
+      [psd.tree, psd.tree.children.first].each do |node|
+        expect(node).to respond_to(:renderer)
+        expect(node).to respond_to(:to_png)
+        expect(node).to respond_to(:save_as_png)
+      end
+    end
+
+    it "returns a Renderer object" do
+      [psd.tree, psd.tree.children.first].each do |node|
+        expect(node.renderer).to be_an_instance_of(PSD::Renderer)
+      end
+    end
+
+    it "produces a correct PNG" do
+      expect(psd.tree.to_png).to be_an_instance_of(ChunkyPNG::Canvas)
+      expect(psd.tree.to_png.pixels).to eq([ChunkyPNG::Color.rgba(0, 100, 200, 255)])
+      expect(psd.tree.to_png[0, 0]).to eq(ChunkyPNG::Color.rgba(0, 100, 200, 255))
+    end
+
+    describe "Canvas" do
+      before do
+        @node = psd.tree.children.first
+        @canvas = PSD::Renderer::Canvas.new(@node)
+      end
+
+      it 'is initialized properly' do
+        expect(@canvas.node).to be @node
+        expect(@canvas.width).to eq @node.width
+        expect(@canvas.height).to eq @node.height
+
+        expect(@canvas.opacity).to eq @node.opacity
+        expect(@canvas.fill_opacity).to eq @node.fill_opacity
+
+        expect(@canvas.canvas).to be_an_instance_of(ChunkyPNG::Canvas)
+        expect(@canvas.instance_variable_get(:@pixel_data)).to be_nil
+        expect(@canvas.canvas.pixels.length).to be 1
+      end
+
+      it 'delegates array methods to internal canvas' do
+        expect(@canvas[0, 0]).to eq ChunkyPNG::Color.rgba(0, 100, 200, 255)
+        expect(@canvas).to respond_to(:[]=)
+      end
+    end
+  end
+end