psd 2.1.2 → 3.9.0

data/lib/psd/mask.rb

@@ -15,6 +15,8 @@ class PSD
       @left = 0
       @bottom = 0
       @right = 0
+      @default_color = 0
+      @flags = 0
     end
 
     def parse
@@ -54,6 +56,10 @@ class PSD
       (@flags & (0x01 << 2)) > 0
     end
 
+    def from_other_data
+      (@flags & (0x01 << 3)) > 0
+    end
+
     def to_hash
       return {} if @size == 0
 
@@ -71,4 +77,4 @@ class PSD
       }
     end
   end
-end
+end

data/lib/psd/node.rb

@@ -1,70 +1,163 @@
-require_relative 'nodes/ancestry'
-require_relative 'nodes/search'
+require 'psd/nodes/ancestry'
+require 'psd/nodes/build_preview'
+require 'psd/nodes/search'
+require 'psd/nodes/layer_comps'
+require 'psd/nodes/locking'
 
 # Internal structure to help us build trees of a Photoshop documents.
 # A lot of method names borrowed from the Ruby ancestry gem.
 class PSD
-  class Node
-    include ParseLayers
-    include Ancestry
-    include Search
-    include BuildPreview
+  module Node
+    class Base
+      extend Forwardable
 
-    # Default properties that all nodes contain
-    PROPERTIES = [:name, :left, :right, :top, :bottom, :height, :width]
+      include Enumerable
+      include Ancestry
+      include Search
+      include LayerComps
+      include BuildPreview
+      include Locking
 
-    attr_accessor :parent, :children, :layer, :force_visible, :top, :left
+      # Default properties that all nodes contain
+      PROPERTIES = [:name, :left, :right, :top, :bottom, :height, :width]
 
-    def initialize(layers=[])
-      parse_layers(layers)
+      attr_reader :id, :name, :parent
+      attr_accessor :children, :layer, :force_visible, :top_offset, :left_offset
 
-      @force_visible = nil
-      @top = @layer.top
-      @left = @layer.left
-    end
+      def_delegators :parent, :psd, :document_dimensions
+      def_delegator :layer, :name
+      def_delegator :children, :each
 
-    def hidden?
-      !visible?
-    end
+      def initialize(layer, parent = nil)
+        @layer = layer
+        @layer.node = self
 
-    def visible?
-      return false if @layer.clipped? && !next_sibling.visible?
-      force_visible.nil? ? @layer.visible? : force_visible
-    end
+        @parent = parent
+        @children = []
+        
+        @id = begin layer.layer_id.id rescue nil end
+        @force_visible = nil
+        @top = @layer.top.to_i
+        @bottom = @layer.bottom.to_i
+        @left = @layer.left.to_i
+        @right = @layer.right.to_i
 
-    def psd
-      parent.psd
-    end
+        @top_offset = 0
+        @left_offset = 0
+      end
 
-    def layer?
-      is_a?(PSD::Node::Layer)
-    end
+      def top
+        @top + @top_offset
+      end
 
-    def group?
-      is_a?(PSD::Node::Group) || is_a?(PSD::Node::Root)
-    end
+      def bottom
+        @bottom + @top_offset
+      end
 
-    def debug_name
-      root? ? ":root:" : name
-    end
+      def left
+        @left + @left_offset
+      end
 
-    def to_hash
-      hash = {
-        type: nil,
-        visible: visible?,
-        opacity: @layer.opacity / 255.0,
-        blending_mode: @layer.blending_mode
-      }
+      def right
+        @right + @left_offset
+      end
 
-      PROPERTIES.each do |p|
-        hash[p] = self.send(p)
+      def width
+        right - left
       end
 
-      hash
-    end
+      def height
+        bottom - top
+      end
+
+      def hidden?
+        !visible?
+      end
+
+      def visible?
+        return false if @layer.clipped? && !clipping_mask.visible?
+        @force_visible.nil? ? @layer.visible? : @force_visible
+      end
+
+      def clipping_mask
+        return nil unless @layer.clipped?
+
+        @clipping_mask ||= (
+          mask_node = next_sibling
+          while mask_node.clipped?
+            mask_node = mask_node.next_sibling
+          end
+
+          mask_node
+        )
+      end
+      alias_method :clipped_by, :clipping_mask
+
+      # Color label is a little tricky. If you set the color of a group, all
+      # of it's descendants inhert the color unless manually overridden. So,
+      # if this node has no defined color, we have to walk up the ancestry tree
+      # to make sure the color isn't set somewhere else.
+      def color_label
+        color = layer.sheet_color.color
+        return color if color != :no_color || node.parent.root?
+
+        parent.color_label
+      end
+
+      def layer?
+        is_a?(PSD::Node::Layer)
+      end
+
+      def group?(include_root = true)
+        is_a?(PSD::Node::Group) || (include_root && is_a?(PSD::Node::Root))
+      end
+
+      def debug_name
+        root? ? ":root:" : name
+      end
+
+      def to_hash
+        hash = {
+          type: nil,
+          visible: visible?,
+          opacity: @layer.opacity / 255.0,
+          blending_mode: @layer.blending_mode,
+          layer_comps: {}
+        }
 
-    def document_dimensions
-      @parent.document_dimensions
+        PROPERTIES.each do |p|
+          hash[p] = self.send(p)
+        end
+
+        root.psd.layer_comps.each do |comp|
+          hash[:layer_comps][comp[:name]] = {
+            visible: visible_in_comp?(comp[:id]),
+            position: position_in_comp(comp[:id])
+          }
+        end
+
+        hash
+      end
+
+      protected
+
+      def update_dimensions!
+        return if layer?
+
+        children.each { |child| child.update_dimensions! }
+
+        return if root?
+
+        non_empty_children = children.reject(&:empty?)
+        @left = non_empty_children.map(&:left).min || 0
+        @top = non_empty_children.map(&:top).min || 0
+        @bottom = non_empty_children.map(&:bottom).max || 0
+        @right = non_empty_children.map(&:right).max || 0
+      end
     end
   end
-end
+end
+
+require 'psd/nodes/group'
+require 'psd/nodes/layer'
+require 'psd/nodes/root'

data/lib/psd/nodes/ancestry.rb

@@ -1,5 +1,5 @@
 class PSD
-  class Node
+  module Node
     # Collection of methods to help in traversing the PSD tree structure.
     module Ancestry
       # Returns the root node
@@ -75,8 +75,9 @@ class PSD
         return ancestors.length + 1
       end
 
-      def path
-        (ancestors.map(&:name) + [name]).join('/')
+      def path(as_array = false)
+        path = (ancestors.map(&:name) + [name])
+        as_array ? path : path.join('/')
       end
 
       def method_missing(method, *args, &block)
@@ -91,8 +92,8 @@ class PSD
 
       private
 
-      def layers_only(d); d.is_a?(PSD::Node::Layer); end
-      def groups_only(d); d.is_a?(PSD::Node::Group); end
+      def layers_only(d); d.layer?; end
+      def groups_only(d); d.group?(false); end
     end
   end
-end
+end

data/lib/psd/nodes/build_preview.rb

@@ -1,12 +1,12 @@
  class PSD
-  class Node
+  module Node
     module BuildPreview
-      def renderer
-        PSD::Renderer.new(self)
+      def renderer(opts = {})
+        PSD::Renderer.new(self, opts)
       end
 
       def to_png
-        renderer.to_png
+        @png ||= renderer(render_hidden: self.layer?).to_png
       end
 
       def save_as_png(output)

data/lib/psd/nodes/group.rb

@@ -0,0 +1,36 @@
+require 'psd/node'
+
+class PSD
+  module Node
+    # Represents a group, or folder, in the PSD document. It can have
+    # zero or more children nodes.
+    class Group < PSD::Node::Base
+      def passthru_blending?
+        blending_mode == 'passthru'
+      end
+
+      def empty?
+        children.each do |child|
+          return false unless child.empty?
+        end
+        
+        return true
+      end
+
+      # Export this layer and it's children to a hash recursively.
+      def to_hash
+        super.merge({
+          type: :group,
+          open: section_divider ? section_divider.layer_type == 'open folder' : false,
+          children: children.map(&:to_hash)
+        })
+      end
+
+      # If the method is missing, we blindly send it to the layer.
+      # The layer handles the case in which the method doesn't exist.
+      def method_missing(method, *args, &block)
+        @layer.send(method, *args, &block)
+      end
+    end
+  end
+end

data/lib/psd/nodes/layer.rb

@@ -0,0 +1,45 @@
+require 'psd/node'
+
+class PSD
+  module Node
+    class Layer < PSD::Node::Base
+      extend Forwardable
+      
+      attr_reader :layer
+
+      def_delegators :@layer, :text, :ref_x, :ref_y, :blending_mode
+      def_delegators :@layer, :text=, :ref_x=, :ref_y=, :blending_mode=
+
+      def empty?
+        width == 0 || height == 0
+      end
+
+      # Exports this layer to a Hash.
+      def to_hash
+        super.merge({
+          type: :layer,
+          text: @layer.text,
+          ref_x: reference_point.x,
+          ref_y: reference_point.y,
+          mask: @layer.mask.to_hash,
+          image: {
+            width: @layer.image.width,
+            height: @layer.image.height,
+            channels: @layer.channels_info
+          }
+        })
+      end
+
+      # In case the layer doesn't have a reference point
+      def reference_point
+        @layer.reference_point || Struct.new(:x, :y).new(0, 0)
+      end
+
+      # If the method is missing, we blindly send it to the layer.
+      # The layer handles the case in which the method doesn't exist.
+      def method_missing(method, *args, &block)
+        @layer.send(method, *args, &block)
+      end
+    end
+  end
+end

data/lib/psd/nodes/layer_comps.rb

@@ -0,0 +1,93 @@
+class PSD
+  module Node
+    module LayerComps
+      # Given a layer comp ID or name, create a new
+      # tree with layer/group visibility altered based on the layer comp.
+      def filter_by_comp(id)
+        comp = find_comp(id)
+        root = PSD::Node::Root.new(psd)
+        
+        # Force layers to be visible if they are enabled for the comp
+        root.descendants.each do |c|
+          set_visibility(comp, c) if Resource::Section::LayerComps.visibility_captured?(comp)
+          set_position(comp, c) if Resource::Section::LayerComps.position_captured?(comp)
+
+          PSD.logger.debug "#{c.path}: visible = #{c.visible?}, position = #{c.left}, #{c.top}"
+        end
+
+        return root
+      end
+
+      def visible_in_comp?(id)
+        determine_visibility(find_comp(id), self)
+      end
+
+      def position_in_comp(id)
+        offset = determine_position_offset(find_comp(id), self)
+        
+        {
+          top: top + offset[:y],
+          right: right + offset[:x],
+          bottom: bottom + offset[:y],
+          left: left + offset[:x]
+        }
+      end
+
+      private
+
+      def find_comp(id)
+        comp = if id.is_a?(String)
+          psd.layer_comps.select { |c| c[:name] == id }.first
+        else
+          psd.layer_comps.select { |c| c[:id] == id }.first
+        end
+
+        raise "Layer comp not found" if comp.nil?
+        comp
+      end
+
+      def set_visibility(comp, c)
+        c.force_visible = determine_visibility(comp, c)
+      end
+
+      def determine_visibility(comp, c)
+        visible = true
+        found = false
+
+        c
+          .metadata
+          .data[:layer_comp]['layerSettings'].each do |l|
+            visible = l['enab'] if l.has_key?('enab')
+            found = true and break if l['compList'].include?(comp[:id])
+          end
+
+        found && visible
+      end
+
+      def set_position(comp, c)
+        offset = determine_position_offset(comp, c)
+        
+        c.left_offset = offset[:x]
+        c.top_offset = offset[:y]
+      end
+
+      def determine_position_offset(comp, c)
+        x = 0
+        y = 0
+
+        c
+          .metadata
+          .data[:layer_comp]['layerSettings'].each do |l|
+            if l.has_key?('Ofst')
+              x = l['Ofst']['Hrzn']
+              y = l['Ofst']['Vrtc']
+            end
+            
+            break if l['compList'].include?(comp[:id])
+          end
+
+        { x: x, y: y }
+      end
+    end
+  end
+end

data/lib/psd/nodes/locking.rb

@@ -0,0 +1,36 @@
+class PSD
+  module Node
+    # Locking is inherited by descendants, but Photoshop doesn't reflect
+    # this directly in the file, so we have to recursively traverse the
+    # ancestry tree to make sure an ancestor isn't locked.
+    module Locking
+      def all_locked?
+        return true if layer.all_locked?
+        return false if parent.root?
+        return parent.all_locked?
+      end
+
+      def any_locked?
+        position_locked? || composite_locked? || transparency_locked?
+      end
+
+      def position_locked?
+        return true if layer.position_locked?
+        return false if parent.root?
+        return parent.position_locked?
+      end
+
+      def composite_locked?
+        return true if layer.composite_locked?
+        return false if parent.root?
+        return parent.composite_locked?
+      end
+
+      def transparency_locked?
+        return true if layer.transparency_locked?
+        return false if parent.root?
+        return parent.transparency_locked?
+      end
+    end
+  end
+end

data/lib/psd/nodes/root.rb

@@ -0,0 +1,87 @@
+require 'psd/node'
+
+class PSD
+  module Node
+    # Represents the root node of a Photoshop document
+    class Root < PSD::Node::Base
+      attr_accessor :children
+      attr_reader :psd
+
+      alias_method :document_width, :width
+      alias_method :document_height, :height
+
+      RootLayer = Struct.new("RootLayer", :node, *Base::PROPERTIES)
+
+      def self.layer_for_psd(psd)
+        RootLayer.new.tap do |layer|
+          layer.top = 0
+          layer.left = 0
+          layer.right = psd.header.width.to_i
+          layer.bottom = psd.header.height.to_i
+        end
+      end
+
+      # Stores a reference to the parsed PSD and builds the
+      # tree hierarchy.
+      def initialize(psd)
+        super self.class.layer_for_psd(psd)
+
+        @psd = psd
+        build_hierarchy
+      end
+
+      # Returns the width and height of the entire PSD document.
+      def document_dimensions
+        [document_width, document_height]
+      end
+
+      # The depth of the root node is always 0.
+      def depth
+        0
+      end
+
+      def opacity; 255; end
+      def fill_opacity; 255; end
+
+      # Recursively exports the hierarchy to a Hash
+      def to_hash
+        {
+          children: children.map(&:to_hash),
+          document: {
+            width: document_width,
+            height: document_height,
+            depth: psd.header.depth,
+            resources: {
+              layer_comps: @psd.layer_comps,
+              guides: @psd.guides,
+              slices: @psd.slices.map(&:to_hash)
+            }
+          }
+        }
+      end
+
+      private
+
+      def build_hierarchy
+        current_group = self
+        parse_stack = []
+
+        # First we build the hierarchy
+        @psd.layers.each do |layer|
+          if layer.folder?
+            parse_stack.push current_group
+            current_group = PSD::Node::Group.new(layer, parse_stack.last)
+          elsif layer.folder_end?
+            parent = parse_stack.pop
+            parent.children.push current_group
+            current_group = parent
+          else
+            current_group.children.push PSD::Node::Layer.new(layer, current_group)
+          end
+        end
+
+        update_dimensions!
+      end
+    end
+  end
+end

data/lib/psd/nodes/search.rb

@@ -1,6 +1,10 @@
 class PSD
-  class Node
+  module Node
     module Search
+      def find_by_id(id)
+        subtree.select { |n| n.id == id }.first
+      end
+
       # 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
@@ -8,6 +12,7 @@ class PSD
       def children_at_path(path, opts={})
         path = path.split('/').delete_if { |p| p == "" } unless path.is_a?(Array)
 
+        path = path.dup
         query = path.shift
         matches = children.select do |c|
           if opts[:case_sensitive]
@@ -20,72 +25,10 @@ class PSD
         if path.length == 0
           return matches
         else
-          return matches.map { |m| m.children_at_path(path, opts) }.flatten
+          return matches.map { |m| m.children_at_path(path.dup, opts) }.flatten
         end
       end
       alias :children_with_path :children_at_path
-
-      # Given a layer comp ID, name, or :last for last document state, create a new
-      # tree with layer/group visibility altered based on the layer comp.
-      def filter_by_comp(id)
-        if id.is_a?(String)
-          comp = psd.layer_comps.select { |c| c[:name] == id }.first
-          raise "Layer comp not found" if comp.nil?
-
-          id = comp[:id]
-        else
-          comp = psd.layer_comps.select { |c| c[:id] == id }.first
-          raise "Layer comp not found" if comp.nil?
-        end
-
-        root = PSD::Node::Root.new(psd)
-        filter_for_comp!(comp, root)
-
-        return root
-      end
-
-      private
-
-      def filter_for_comp!(comp, node)
-        # Force layers to be visible if they are enabled for the comp
-        node.children.each do |c|
-          set_visibility(comp, c) if Resource::Section::LayerComps.visibility_captured?(comp)
-          set_position(comp, c) if Resource::Section::LayerComps.position_captured?(comp)
-
-          filter_for_comp!(comp, c) if c.group?
-        end
-      end
-
-      def set_visibility(comp, c)
-        visible = true
-
-        c
-          .metadata
-          .data[:layer_comp]['layerSettings'].each do |l|
-            visible = l['enab'] if l.has_key?('enab')
-            break if l['compList'].include?(comp[:id])
-          end
-
-        c.force_visible = visible
-      end
-
-      def set_position(comp, c)
-        x = 0
-        y = 0
-
-        c
-          .metadata
-          .data[:layer_comp]['layerSettings'].each do |l|
-            next unless l.has_key?('Ofst')
-            
-            x = l['Ofst']['Hrzn']
-            y = l['Ofst']['Vrtc']
-            break if l['compList'].include?(comp[:id])
-          end
-
-        c.left += x
-        c.top += y
-      end
     end
   end
-end
+end