psd 2.1.2 → 3.1.2

data/lib/psd/layer_info/vector_mask.rb

@@ -1,8 +1,10 @@
-require_relative '../layer_info'
+require 'psd/layer_info'
 
 class PSD
   class VectorMask < LayerInfo
-    @key = 'vmsk'
+    def self.should_parse?(key)
+      ['vmsk', 'vsms'].include?(key)
+    end
 
     attr_reader :invert, :not_link, :disable, :paths
 

data/lib/psd/layer_info/vector_origination.rb

@@ -0,0 +1,14 @@
+require 'psd/layer_info'
+
+class PSD
+  class VectorOrigination < LayerInfo
+    def self.should_parse?(key)
+      key == 'vogk'
+    end
+
+    def parse
+      @file.seek 8, IO::SEEK_CUR
+      @data = Descriptor.new(@file).parse
+    end
+  end
+end

data/lib/psd/layer_info/vector_stroke.rb

@@ -1,8 +1,10 @@
-require_relative '../layer_info'
+require 'psd/layer_info'
 
 class PSD
   class VectorStroke < LayerInfo
-    @key = 'vstk'
+    def self.should_parse?(key)
+      key == 'vstk'
+    end
 
     def parse
       version = @file.read_int

data/lib/psd/layer_info/vector_stroke_content.rb

@@ -1,8 +1,10 @@
-require_relative '../layer_info'
+require 'psd/layer_info'
 
 class PSD
   class VectorStrokeContent < LayerInfo
-    @key = 'vscg'
+    def self.should_parse?(key)
+      key == 'vscg'
+    end
 
     attr_reader :key
     

data/lib/psd/layer_mask.rb

@@ -2,8 +2,6 @@ class PSD
   # Covers parsing the global mask and controls parsing of all the
   # layers/folders in the document.
   class LayerMask
-    include Section
-
     attr_reader :layers, :global_mask
 
     # Store a reference to the file and the header and initialize the defaults.
@@ -25,11 +23,8 @@ class PSD
       return self
     end
 
-    # Parse this section, including all of the layers and folders. Once implemented, this
-    # will also trigger parsing of the channel images for each layer.
+    # Parse this section, including all of the layers and folders.
     def parse
-      start_section
-
       mask_size = @file.read_int
       finish = @file.tell + mask_size
 
@@ -46,7 +41,7 @@ class PSD
         end
 
         if layer_count * (18 + 6 * @header.channels) > layer_info_size
-          raise "Unlikely number of layers parsed: #{layer_count}"
+          PSD.logger.error "Unlikely number of layers parsed: #{layer_count}"
         end
 
         @layer_section_start = @file.tell
@@ -67,7 +62,6 @@ class PSD
 
       # Ensure we're at the end of this section
       @file.seek finish
-      end_section
 
       return self
     end

data/lib/psd/lazy_execute.rb

@@ -41,7 +41,11 @@ class PSD
     end
 
     def inspect
-      "<PSD::LazyExecute @obj=#{@obj.class.name}, @pos=#{@start_pos}, @load_method=:#{@load_method}>"
+      if loaded?
+        @obj.inspect
+      else
+        "<PSD::LazyExecute @obj=#{@obj.class.name}, @pos=#{@start_pos}, @load_method=:#{@load_method}>"
+      end
     end
 
     private

data/lib/psd/node.rb

@@ -1,70 +1,134 @@
-require_relative 'nodes/ancestry'
-require_relative 'nodes/search'
+require 'psd/nodes/ancestry'
+require 'psd/nodes/search'
+require 'psd/nodes/build_preview'
 
 # 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
+      include Enumerable
+      include Ancestry
+      include Search
+      include BuildPreview
 
-    # Default properties that all nodes contain
-    PROPERTIES = [:name, :left, :right, :top, :bottom, :height, :width]
+      # Default properties that all nodes contain
+      PROPERTIES = [:name, :left, :right, :top, :bottom, :height, :width]
 
-    attr_accessor :parent, :children, :layer, :force_visible, :top, :left
+      attr_reader :name, :parent
+      attr_accessor :children, :layer, :force_visible, :top_offset, :left_offset
 
-    def initialize(layers=[])
-      parse_layers(layers)
+      delegate :psd, to: :parent
+      delegate :name, to: :layer
+      delegate :each, to: :children
+      delegate :document_dimensions, to: :parent
 
-      @force_visible = nil
-      @top = @layer.top
-      @left = @layer.left
-    end
+      def initialize(layer, parent = nil)
+        @layer = layer
+        @layer.node = self
 
-    def hidden?
-      !visible?
-    end
+        @parent = parent
+        @children = []
+        
+        @force_visible = nil
+        @top = @layer.top.to_i
+        @bottom = @layer.bottom.to_i
+        @left = @layer.left.to_i
+        @right = @layer.right.to_i
 
-    def visible?
-      return false if @layer.clipped? && !next_sibling.visible?
-      force_visible.nil? ? @layer.visible? : force_visible
-    end
+        @top_offset = 0
+        @left_offset = 0
+      end
 
-    def psd
-      parent.psd
-    end
+      def top
+        @top + @top_offset
+      end
 
-    def layer?
-      is_a?(PSD::Node::Layer)
-    end
+      def bottom
+        @bottom + @top_offset
+      end
 
-    def group?
-      is_a?(PSD::Node::Group) || is_a?(PSD::Node::Root)
-    end
+      def left
+        @left + @left_offset
+      end
 
-    def debug_name
-      root? ? ":root:" : name
-    end
+      def right
+        @right + @left_offset
+      end
 
-    def to_hash
-      hash = {
-        type: nil,
-        visible: visible?,
-        opacity: @layer.opacity / 255.0,
-        blending_mode: @layer.blending_mode
-      }
+      def width
+        right - left
+      end
 
-      PROPERTIES.each do |p|
-        hash[p] = self.send(p)
+      def height
+        bottom - top
       end
 
-      hash
-    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?
 
-    def document_dimensions
-      @parent.document_dimensions
+        @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
+
+      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
+        }
+
+        PROPERTIES.each do |p|
+          hash[p] = self.send(p)
+        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

data/lib/psd/nodes/ancestry.rb

@@ -1,98 +1,103 @@
 class PSD
-  class Node
+  module Node
     # Collection of methods to help in traversing the PSD tree structure.
     module Ancestry
-      # Returns the root node
-      def root
-        return self if is_root?
-        return parent.root
-      end
+      extend ActiveSupport::Concern
 
-      # Is this node the root node?
-      def root?
-        self.is_a?(PSD::Node::Root)
-      end
-      alias :is_root? :root?
+      included do
+        # Returns the root node
+        def root
+          return self if is_root?
+          return parent.root
+        end
 
-      # Returns all ancestors in the path of this node. This
-      # does NOT return the root node.
-      def ancestors
-        return [] if parent.nil? || parent.is_root?
-        return parent.ancestors + [parent]
-      end
+        # Is this node the root node?
+        def root?
+          self.is_a?(PSD::Node::Root)
+        end
+        alias :is_root? :root?
 
-      # Does this node have any children nodes?
-      def has_children?
-        children.length > 0
-      end
+        # Returns all ancestors in the path of this node. This
+        # does NOT return the root node.
+        def ancestors
+          return [] if parent.nil? || parent.is_root?
+          return parent.ancestors + [parent]
+        end
 
-      # Inverse of has_children?
-      def childless?
-        !has_children?
-      end
+        # Does this node have any children nodes?
+        def has_children?
+          children.length > 0
+        end
 
-      # Returns all sibling nodes including the current node. Can also
-      # be thought of as all children of the parent of this node.
-      def siblings
-        return [] if parent.nil?
-        parent.children
-      end
+        # Inverse of has_children?
+        def childless?
+          !has_children?
+        end
 
-      def next_sibling
-        return nil if parent.nil?
-        index = siblings.index(self)
-        siblings[index + 1]
-      end
+        # Returns all sibling nodes including the current node. Can also
+        # be thought of as all children of the parent of this node.
+        def siblings
+          return [] if parent.nil?
+          parent.children
+        end
 
-      def prev_sibling
-        return nil if parent.nil?
-        index = siblings.index(self)
-        siblings[index - 1]
-      end
+        def next_sibling
+          return nil if parent.nil?
+          index = siblings.index(self)
+          siblings[index + 1]
+        end
 
-      # Does this node have any siblings?
-      def has_siblings?
-        siblings.length > 1
-      end
+        def prev_sibling
+          return nil if parent.nil?
+          index = siblings.index(self)
+          siblings[index - 1]
+        end
 
-      # Is this node the only descendant of its parent?
-      def only_child?
-        siblings.length == 1
-      end
+        # Does this node have any siblings?
+        def has_siblings?
+          siblings.length > 1
+        end
 
-      # Recursively get all descendant nodes, not including this node.
-      def descendants
-        children.map(&:subtree).flatten
-      end
+        # Is this node the only descendant of its parent?
+        def only_child?
+          siblings.length == 1
+        end
 
-      # Same as descendants, except it includes this node.
-      def subtree
-        [self] + descendants
-      end
+        # Recursively get all descendant nodes, not including this node.
+        def descendants
+          children.map(&:subtree).flatten
+        end
 
-      # Depth from the root node. Root depth is 0.
-      def depth
-        return ancestors.length + 1
-      end
+        # Same as descendants, except it includes this node.
+        def subtree
+          [self] + descendants
+        end
 
-      def path
-        (ancestors.map(&:name) + [name]).join('/')
-      end
+        # Depth from the root node. Root depth is 0.
+        def depth
+          return ancestors.length + 1
+        end
 
-      def method_missing(method, *args, &block)
-        test = /^(.+)_(layers|groups)$/.match(method)
-        if test
-          m = self.respond_to?(test[1]) ? test[1] : "#{test[1]}s"
-          self.send(m).select &method("#{test[2]}_only")
-        else
-          super
+        def path(as_array = false)
+          path = (ancestors.map(&:name) + [name])
+          as_array ? path : path.join('/')
         end
-      end
 
-      private
+        def method_missing(method, *args, &block)
+          test = /^(.+)_(layers|groups)$/.match(method)
+          if test
+            m = self.respond_to?(test[1]) ? test[1] : "#{test[1]}s"
+            self.send(m).select &method("#{test[2]}_only")
+          else
+            super
+          end
+        end
+
+        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