psd 1.4.5 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c9491d68bacd47bd02b6ef1ebd95679de8f780d
-  data.tar.gz: 3890b2b104af1b45d7754005cf91736cfd88c2fa
+  metadata.gz: 87dd8d12bd49feb7ad2502047fa2ec73d4aff7b1
+  data.tar.gz: 5647eca77e19f0a4ebb3ac59448d8b26d0f56da8
 SHA512:
-  metadata.gz: 03d6f9c5332ca2b8ac5e981743e3955f0b26d5cd8f6b3ec7643602cebd4d7f0ac766190e1ca7d4e6618c9784d33d319a7ab8b548919bd491079096290ca74166
-  data.tar.gz: e94c59785c2d9e6cac71e44e2f5a4efc8961e32da61f8382e36682af3a9ab6c58dba757a4411f383f87c6bc1a69cd9eaf9a5eedaa87ce4b2e6163b1d8e26a842
+  metadata.gz: d82f2fde33a13a60863548bc75788ffd279651e1c66a553749d794080733463e4f78cf13cfbcbf58a4d6296579f678cc3e32a0e6419c83ef7273e1b41d1406c5
+  data.tar.gz: 23a3d1ba099ed12c363958af463393e56702e2ac2a02ba67a9af247016fbe2f384f893f5ea5dad4bdb651cb76196f9a77d42efe69cf7ced445ea6177e4ffbffe

data/lib/psd/channel_image.rb

@@ -39,7 +39,6 @@ class PSD
       PSD.logger.debug @channels_info
 
       @chan_pos = 0
-
       @channels_info.each do |ch_info|
         @ch_info = ch_info
         if ch_info[:length] <= 0

data/lib/psd/compose.rb

@@ -17,7 +17,7 @@ class PSD
 
     # Normal composition, delegate to ChunkyPNG
     def normal(fg, bg, opts={})
-      return fg if opaque?(fg) || fully_transparent?(bg)
+      return fg if fully_transparent?(bg)
       return bg if fully_transparent?(fg)
 
       mix_alpha, dst_alpha = calculate_alphas(fg, bg, DEFAULT_OPTS.merge(opts))

data/lib/psd/file.rb

@@ -72,7 +72,7 @@ class PSD
     # Reads a string of the given length and converts it to UTF-8 from the internally used MacRoman encoding.
     def read_string(length=nil)
       length = @file.read(1).bytes.to_a[0] if length.nil?
-      read(length).encode('UTF-8', 'MacRoman').delete("\000")
+      read(length).delete("\000")
     end
 
     def read_byte

data/lib/psd/image_exports/png.rb

@@ -7,31 +7,34 @@ class PSD::Image
       # Load the image pixels into a PNG file and return a reference to the
       # data.
       def to_png
+        return @png if @png
+
         PSD.logger.debug "Beginning PNG export"
-        png = ChunkyPNG::Canvas.new(width.to_i, height.to_i, ChunkyPNG::Color::TRANSPARENT)
+        @png = ChunkyPNG::Canvas.new(width.to_i, height.to_i, ChunkyPNG::Color::TRANSPARENT)
 
         i = 0
         height.times do |y|
           width.times do |x|
-            png[x,y] = @pixel_data[i]
+            @png[x,y] = @pixel_data[i]
             i += 1
           end
         end
 
-        png
+        @png
       end
       alias :export :to_png
 
       def to_png_with_mask
         return to_png unless has_mask?
+        return @png_with_mask if @png_with_mask
 
         PSD.logger.debug "Beginning PNG export with mask"
-        
+
         # We generate the preview at the document size instead to make applying the mask
         # significantly easier.
         width = @layer.header.width.to_i
         height = @layer.header.height.to_i
-        png = ChunkyPNG::Canvas.new(width, height, ChunkyPNG::Color::TRANSPARENT)
+        @png_with_mask = ChunkyPNG::Canvas.new(width, height, ChunkyPNG::Color::TRANSPARENT)
 
         i = 0
         @layer.height.times do |y|
@@ -39,13 +42,13 @@ class PSD::Image
             offset_x = x + @layer.left
             offset_y = y + @layer.top
 
-            i +=1 and next if offset_x < 0 || offset_y < 0 || offset_x >= png.width || offset_y >= png.height
+            i +=1 and next if offset_x < 0 || offset_y < 0 || offset_x >= @png_with_mask.width || offset_y >= @png_with_mask.height
 
-            png[offset_x, offset_y] = @pixel_data[i]
+            @png_with_mask[offset_x, offset_y] = @pixel_data[i]
             i += 1
           end
         end
-        
+
         # Now we apply the mask
         i = 0
         @layer.mask.height.times do |y|
@@ -53,22 +56,22 @@ class PSD::Image
             offset_x = @layer.mask.left + x
             offset_y = @layer.mask.top + y
 
-            i += 1 and next if offset_x < 0 || offset_y < 0 || offset_x >= png.width || offset_y >= png.height
+            i += 1 and next if offset_x < 0 || offset_y < 0 || offset_x >= @png_with_mask.width || offset_y >= @png_with_mask.height
 
-            color = ChunkyPNG::Color.to_truecolor_alpha_bytes(png[offset_x, offset_y])
+            color = ChunkyPNG::Color.to_truecolor_alpha_bytes(@png_with_mask[offset_x, offset_y])
             color[3] = color[3] * @mask_data[i] / 255
 
-            png[offset_x, offset_y] = ChunkyPNG::Color.rgba(*color)
+            @png_with_mask[offset_x, offset_y] = ChunkyPNG::Color.rgba(*color)
             i += 1
           end
         end
 
-        crop_left = PSD::Util.clamp(@layer.left, 0, png.width)
-        crop_top = PSD::Util.clamp(@layer.top, 0, png.height)
-        crop_width = PSD::Util.clamp(@layer.width.to_i, 0, png.width - crop_left)
-        crop_height = PSD::Util.clamp(@layer.height.to_i, 0, png.height - crop_top)
+        crop_left = PSD::Util.clamp(@layer.left, 0, @png_with_mask.width)
+        crop_top = PSD::Util.clamp(@layer.top, 0, @png_with_mask.height)
+        crop_width = PSD::Util.clamp(@layer.width.to_i, 0, @png_with_mask.width - crop_left)
+        crop_height = PSD::Util.clamp(@layer.height.to_i, 0, @png_with_mask.height - crop_top)
 
-        png.crop!(crop_left, crop_top, crop_width, crop_height)
+        @png_with_mask.crop!(crop_left, crop_top, crop_width, crop_height)
       end
 
       def mask_to_png
@@ -93,4 +96,4 @@ class PSD::Image
       end
     end
   end
-end
+end

data/lib/psd/image_formats/layer_rle.rb

@@ -16,7 +16,7 @@ class PSD
       def parse_channel_data!
         @line_index = 0
 
-        PSD.logger.debug "Parsing layer RLE channel ##{@ch_info[:id]}: position = #{@chan_pos}"
+        PSD.logger.debug "Parsing RLE channel ##{@ch_info[:id]}: file position = #{@file.tell}, image position = #{@chan_pos}, line = #{@line_index}"
         decode_rle_channel
       end
     end

data/lib/psd/image_formats/rle.rb

@@ -23,7 +23,7 @@ class PSD
         @line_index = 0
 
         channels.times do |i|
-          PSD.logger.debug "Parsing RLE channel ##{i}: position = #{@chan_pos}, line = #{@line_index}"
+          PSD.logger.debug "Parsing RLE channel ##{i}: file position = #{@file.tell}, image position = #{@chan_pos}, line = #{@line_index}"
           decode_rle_channel
           @line_index += height
         end

data/lib/psd/layer/helpers.rb

@@ -23,6 +23,30 @@ class PSD
         end
       end
 
+      # Is the layer completely locked?
+      def all_locked?
+        return false unless info.has_key?(:locked)
+        info[:locked].all_locked
+      end
+
+      # Is the layer position locked?
+      def position_locked?
+        return false unless info.has_key?(:locked)
+        info[:locked].position_locked
+      end
+
+      # Is the layer composite locked?
+      def composite_locked?
+        return false unless info.has_key?(:locked)
+        info[:locked].composite_locked
+      end
+
+      # Is the layer transparency locked?
+      def transparency_locked?
+        return false unless info.has_key?(:locked)
+        info[:locked].transparency_locked
+      end
+
       # Is this layer visible?
       def visible?
         @visible

data/lib/psd/layer/info.rb

@@ -17,6 +17,7 @@ class PSD
         layer_id: LayerID,
         fill_opacity: FillOpacity,
         placed_layer: PlacedLayer,
+        locked: Locked,
         vector_mask: VectorMask,
         vector_mask_2: VectorMask2,
         vector_stroke: VectorStroke,
@@ -52,6 +53,7 @@ class PSD
 
             i = info.new(self, length)
             @adjustments[name] = LazyExecute.new(i, @file).now(:skip).later(:parse)
+              
             key_parseable = true and break
           end
 

data/lib/psd/layer_info/locked.rb

@@ -0,0 +1,19 @@
+require_relative '../layer_info'
+
+class PSD
+  class Locked < LayerInfo
+    @key = 'lspf'
+
+    attr_reader :all_locked, :transparency_locked, :composite_locked, :position_locked
+
+    def parse
+      locked = @file.read_int
+
+      @transparency_locked = (locked & (0x01 << 0)) > 0 || locked == -2147483648
+      @composite_locked = (locked & (0x01 << 1)) > 0 || locked == -2147483648
+      @position_locked = (locked & (0x01 << 2)) > 0 || locked == -2147483648
+      
+      @all_locked = @transparency_locked && @composite_locked && @position_locked
+    end
+  end
+end

data/lib/psd/layer_info/typetool.rb

@@ -17,7 +17,7 @@ class PSD
 
       @data[:text] = Descriptor.new(@file).parse
       @data[:text]['EngineData']
-        .encode!('UTF-8', 'MacRoman')
+        .encode!('UTF-8', 'MacRoman', invalid: :replace, undef: :replace)
         .delete!("\000")
 
       @data[:engine_data] = nil

data/lib/psd/layer_mask.rb

@@ -55,7 +55,6 @@ class PSD
         end
 
         layers.each do |layer|
-          @file.seek 8, IO::SEEK_CUR and next if layer.folder? || layer.folder_end?
           layer.parse_channel_image(@header)
         end
       end

data/lib/psd/node_group.rb

@@ -46,6 +46,10 @@ class PSD::Node
       @children.each{ |c| c.show! }
     end
 
+    def empty?
+      @children.empty?
+    end
+
     # Export this layer and it's children to a hash recursively.
     def to_hash
       super.merge({
@@ -64,10 +68,11 @@ class PSD::Node
     private
 
     def get_dimensions
-      @left = @children.map(&:left).min || 0
-      @top = @children.map(&:top).min || 0
-      @bottom = @children.map(&:bottom).max || 0
-      @right = @children.map(&:right).max || 0
+      children = @children.reject(&:empty?)
+      @left = children.map(&:left).min || 0
+      @top = children.map(&:top).min || 0
+      @bottom = children.map(&:bottom).max || 0
+      @right = children.map(&:right).max || 0
     end
   end
 end

data/lib/psd/node_layer.rb

@@ -52,6 +52,10 @@ class PSD::Node
       end
     end
 
+    def empty?
+      width == 0 || height == 0
+    end
+
     # Exports this layer to a Hash.
     def to_hash
       super.merge({

data/lib/psd/nodes/build_preview.rb

@@ -6,7 +6,7 @@ class PSD
       alias :orig_to_png :to_png
       def to_png
         return build_png if group?
-        layer.image.to_png
+        layer.image.to_png_with_mask
       end
 
       def build_png(png=nil)
@@ -14,7 +14,7 @@ class PSD
 
         children.reverse.each do |c|
           next unless c.visible?
-          
+
           if c.group?
             if c.blending_mode == 'passthru'
               c.build_png(png)
@@ -23,10 +23,10 @@ class PSD
             end
           else
             compose!(
-              c, 
-              png, 
-              c.image.to_png_with_mask, 
-              PSD::Util.clamp(c.left.to_i, 0, png.width), 
+              c,
+              png,
+              c.image.to_png_with_mask,
+              PSD::Util.clamp(c.left.to_i, 0, png.width),
               PSD::Util.clamp(c.top.to_i, 0, png.height)
             )
           end
@@ -59,11 +59,11 @@ class PSD
           other.width.times do |x|
             base_x = x + offset_x
             base_y = y + offset_y
-            
+
             next if base_x < 0 || base_y < 0 || base_x >= base.width || base_y >= base.height
 
             color = Compose.send(
-              blending_mode, 
+              blending_mode,
               other[x, y],
               base[base_x, base_y],
               opacity: layer.opacity,
@@ -76,4 +76,4 @@ class PSD
       end
     end
   end
-end
+end

data/lib/psd/resources/slices.rb

@@ -1,27 +1,132 @@
 class PSD
   class Resource
     class Section
-        class Slices < Section
-          attr_reader :data, :version
+      class Slices < Section
+        attr_reader :data, :version
 
-          def self.id; 1050; end
-          def self.name; :slices; end
+        def self.id; 1050; end
+        def self.name; :slices; end
 
-          def parse
-            @version = @file.read_int
-            @descriptor_version = @file.read_int
-            @resource.data = self
+        def parse
+          @version = @file.read_int
 
-            if @version == 7 || @version == 8
-              @data = Descriptor.new(@file).parse
-            end
+          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
 
-          def to_a
-            @data.nil? ? [] : @data['slices']
+        # 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/lib/psd/version.rb

@@ -1,3 +1,3 @@
 class PSD
-  VERSION = "1.4.5"
+  VERSION = "1.5.0"
 end

data/spec/hierarchy_spec.rb

@@ -27,7 +27,7 @@ describe "Hierarchy" do
     end
 
     it "should properly identify the root node" do
-      expect(@tree.root?).to be_true
+      expect(@tree.root?).to be true
       expect(@tree.root).to be @tree
       expect(@tree.children.last.root).to be @tree
     end
@@ -105,4 +105,24 @@ describe "Hierarchy" do
       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
 end

data/spec/image_spec.rb

@@ -1,39 +1,33 @@
 require 'spec_helper'
 
 describe 'Image Exporting' do
-  before(:each) do
-    class PSD::Image 
-      attr_accessor :pixel_data
-    end
-
-    @psd = PSD.new('spec/files/pixel.psd')
-  end
+  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)])
+      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)])
+      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).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(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])
+          ChunkyPNG::Color.to_truecolor_alpha_bytes(psd.image.to_png[0,0])
         ).to eq([0, 100, 200, 255])
       end
     end
@@ -41,10 +35,10 @@ describe 'Image Exporting' do
 
   describe "layer images" do
     it "should successfully parse the image data" do
-      @psd.options[:parse_layer_images] = true
-      @psd.parse!
+      psd.options[:parse_layer_images] = true
+      psd.parse!
 
-      image = @psd.tree.children.first.image
+      image = psd.tree.children.first.image
       expect(image.width).to eq(1)
       expect(image.height).to eq(1)
 
@@ -53,10 +47,10 @@ describe 'Image Exporting' do
 
     describe "as PNG" do
       it "should produce a valid PNG object" do
-        @psd.options[:parse_layer_images] = true
-        @psd.parse!
+        psd.options[:parse_layer_images] = true
+        psd.parse!
 
-        png = @psd.tree.children.first.image.to_png
+        png = psd.tree.children.first.image.to_png
         expect(png).to be_an_instance_of(ChunkyPNG::Canvas)
         expect(png.width).to eq(1)
         expect(png.height).to eq(1)
@@ -64,6 +58,28 @@ describe 'Image Exporting' do
           ChunkyPNG::Color.to_truecolor_alpha_bytes(png[0,0])
         ).to eq([0, 100, 200, 255])
       end
+
+      it "memorizes the png instance" do
+        psd.options[:parse_layer_images] = true
+        psd.parse!
+
+        node = psd.tree.children.first
+        png  = node.image.to_png
+
+        expect(png).to be_an_instance_of(ChunkyPNG::Canvas)
+        expect(node.image.to_png.__id__).to eq(png.__id__)
+      end
+
+      it "memorizes the png_with_mask instance" do
+        psd = PSD.new('spec/files/path.psd', parse_layer_images: true)
+        psd.parse!
+
+        node = psd.tree.children.first
+        png  = node.image.to_png_with_mask
+
+        expect(png).to be_an_instance_of(ChunkyPNG::Canvas)
+        expect(node.image.to_png_with_mask.__id__).to eq(png.__id__)
+      end
     end
   end
-end
+end

data/spec/locked_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe 'Locked' do
+  it "should parse locked layer info" do
+    psd = PSD.new('spec/files/locked.psd')
+    psd.parse!
+
+    expect(psd.tree.children[0].position_locked?).to eq(true)
+    expect(psd.tree.children[0].all_locked?).to eq(true)
+    expect(psd.tree.children[0].composite_locked?).to eq(true)
+    expect(psd.tree.children[0].transparency_locked?).to eq(true)
+    
+    expect(psd.tree.children[1].position_locked?).to eq(true)
+    expect(psd.tree.children[1].all_locked?).to eq(false)
+    expect(psd.tree.children[1].composite_locked?).to eq(false)
+    expect(psd.tree.children[1].transparency_locked?).to eq(false)
+    
+    expect(psd.tree.children[2].position_locked?).to eq(false)
+    expect(psd.tree.children[2].all_locked?).to eq(false)
+    expect(psd.tree.children[2].composite_locked?).to eq(true)
+    expect(psd.tree.children[2].transparency_locked?).to eq(false)
+
+    expect(psd.tree.children[3].position_locked?).to eq(false)
+    expect(psd.tree.children[3].all_locked?).to eq(false)
+    expect(psd.tree.children[3].composite_locked?).to eq(false)
+    expect(psd.tree.children[3].transparency_locked?).to eq(true)
+
+    expect(psd.tree.children[4].position_locked?).to eq(true)
+    expect(psd.tree.children[4].all_locked?).to eq(false)
+    expect(psd.tree.children[4].composite_locked?).to eq(true)
+    expect(psd.tree.children[4].transparency_locked?).to eq(false)
+
+    expect(psd.tree.children[5].position_locked?).to eq(true)
+    expect(psd.tree.children[5].all_locked?).to eq(false)
+    expect(psd.tree.children[5].composite_locked?).to eq(false)
+    expect(psd.tree.children[5].transparency_locked?).to eq(true)
+
+    expect(psd.tree.children[6].position_locked?).to eq(false)
+    expect(psd.tree.children[6].all_locked?).to eq(false)
+    expect(psd.tree.children[6].composite_locked?).to eq(false)
+    expect(psd.tree.children[6].transparency_locked?).to eq(false)
+
+    expect(psd.tree.children[7].position_locked?).to eq(true)
+    expect(psd.tree.children[7].all_locked?).to eq(true)
+    expect(psd.tree.children[7].composite_locked?).to eq(true)
+    expect(psd.tree.children[7].transparency_locked?).to eq(true)
+
+    expect(psd.tree.children[7].children[0].position_locked?).to eq(false)
+    expect(psd.tree.children[7].children[0].all_locked?).to eq(false)
+    expect(psd.tree.children[7].children[0].composite_locked?).to eq(false)
+    expect(psd.tree.children[7].children[0].transparency_locked?).to eq(false)
+
+    expect(psd.tree.children[7].children[1].position_locked?).to eq(true)
+    expect(psd.tree.children[7].children[1].all_locked?).to eq(true)
+    expect(psd.tree.children[7].children[1].composite_locked?).to eq(true)
+    expect(psd.tree.children[7].children[1].transparency_locked?).to eq(true)
+
+    expect(psd.tree.children[7].children[1].children[0].position_locked?).to eq(true)
+    expect(psd.tree.children[7].children[1].children[0].all_locked?).to eq(false)
+    expect(psd.tree.children[7].children[1].children[0].composite_locked?).to eq(false)
+    expect(psd.tree.children[7].children[1].children[0].transparency_locked?).to eq(false)
+
+    expect(psd.tree.children[8].position_locked?).to eq(true)
+    expect(psd.tree.children[8].all_locked?).to eq(false)
+    expect(psd.tree.children[8].composite_locked?).to eq(false)
+    expect(psd.tree.children[8].transparency_locked?).to eq(true)
+
+    expect(psd.tree.children[9].position_locked?).to eq(true)
+    expect(psd.tree.children[9].all_locked?).to eq(true)
+    expect(psd.tree.children[9].composite_locked?).to eq(true)
+    expect(psd.tree.children[9].transparency_locked?).to eq(true)
+
+    expect(psd.tree.children[12].position_locked?).to eq(false)
+    expect(psd.tree.children[12].all_locked?).to eq(false)
+    expect(psd.tree.children[12].composite_locked?).to eq(false)
+    expect(psd.tree.children[12].transparency_locked?).to eq(false)
+  end
+end

data/spec/parsing_spec.rb

@@ -131,7 +131,7 @@ describe 'Parsing' do
       expect(blend_mode.mode).to eq('normal')
       expect(blend_mode.opacity).to eq(255)
       expect(blend_mode.opacity_percentage).to eq(100)
-      expect(blend_mode.visible).to be_true
+      expect(blend_mode.visible).to be true
     end
 
     it "should parse all layer comps" do

data/spec/slices_spec.rb

@@ -1,10 +1,7 @@
 require 'spec_helper'
 
 describe 'Slices' do
-
   describe "Handle file with slice properly" do
-
-
     it "should successfully parse a the PSD file of version 7 or above and has slices" do
       psd = PSD.new('spec/files/slices.psd')
       psd.parse!
@@ -21,11 +18,10 @@ describe 'Slices' do
       # Bounds of each slice should not be nil
       psd.resources[:slices].data.to_a.each do |slice|
         expect(slice).to_not be_nil
-        expect(slice['bounds']).to_not be_nil
+        expect(slice[:bounds]).to_not be_nil
       end
     end
 
-
     it "should successfully parse a the PSD file of version 6 and has slices" do
       psd = PSD.new('spec/files/pixel.psd')
       psd.parse!
@@ -39,14 +35,23 @@ describe 'Slices' do
       # But slices version should be equal to 6
       expect(psd.resources[:slices].data.version).to eq 6
 
-      # Slices data to be nil
-      expect(psd.resources[:slices].data.to_a).to eq []
+      # Bounds should not be nil
+      psd.resources[:slices].data.to_a.each do |slice|
+        expect(slice).to_not be_nil
+        expect(slice[:bounds]).to_not be_nil
+      end
     end
   end
 
   describe "Handle file without slices properly" do
-    #TODO: All files have atleast one autogenerated slice. Dunno how to handle this case yet!
-    #it "should successfully parse a PSD file which does not have slices" do
-    #end
+    it "should successfully parse a PSD file which does not have slices" do
+      psd = PSD.new('spec/files/simplest.psd')
+      psd.parse!
+
+      expect(psd).to be_parsed
+
+      expect(psd.resources[:slices].data.to_a.size).to be 1
+      expect(psd.resources[:slices].data.to_a[0][:id]).to be 0
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: psd
 version: !ruby/object:Gem::Version
-  version: 1.4.5
+  version: 1.5.0
 platform: ruby
 authors:
 - Ryan LeFevre
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-26 00:00:00.000000000 Z
+date: 2013-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -180,6 +180,7 @@ files:
 - lib/psd/layer_info/layer_name_source.rb
 - lib/psd/layer_info/layer_section_divider.rb
 - lib/psd/layer_info/legacy_typetool.rb
+- lib/psd/layer_info/locked.rb
 - lib/psd/layer_info/metadata_setting.rb
 - lib/psd/layer_info/object_effects.rb
 - lib/psd/layer_info/placed_layer.rb
@@ -216,7 +217,9 @@ files:
 - lib/psd/util.rb
 - lib/psd/version.rb
 - psd.gemspec
+- spec/files/empty-layer.psd
 - spec/files/example.psd
+- spec/files/locked.psd
 - spec/files/one_layer.psd
 - spec/files/path.psd
 - spec/files/pixel.psd
@@ -226,6 +229,7 @@ files:
 - spec/hierarchy_spec.rb
 - spec/image_spec.rb
 - spec/lazy_execute_spec.rb
+- spec/locked_spec.rb
 - spec/parsing_spec.rb
 - spec/psd_spec.rb
 - spec/slices_spec.rb
@@ -256,7 +260,9 @@ signing_key:
 specification_version: 4
 summary: General purpose library for parsing Photoshop files
 test_files:
+- spec/files/empty-layer.psd
 - spec/files/example.psd
+- spec/files/locked.psd
 - spec/files/one_layer.psd
 - spec/files/path.psd
 - spec/files/pixel.psd
@@ -266,6 +272,7 @@ test_files:
 - spec/hierarchy_spec.rb
 - spec/image_spec.rb
 - spec/lazy_execute_spec.rb
+- spec/locked_spec.rb
 - spec/parsing_spec.rb
 - spec/psd_spec.rb
 - spec/slices_spec.rb