psd 0.3.2

data/lib/psd/mask.rb

@@ -0,0 +1,45 @@
+class PSD
+  # Represents the mask for a single layer
+  class Mask < BinData::Record
+    endian :big
+
+    int32  :mask_size
+
+    int32 :top,           onlyif: :has_data?
+    int32 :left,          onlyif: :has_data?
+    int32 :bottom,        onlyif: :has_data?
+    int32 :right,         onlyif: :has_data?
+    int8  :default_color, onlyif: :has_data?
+    bit8  :flags,         onlyif: :has_data?
+
+    skip length: 2,   onlyif: lambda { mask_size == 20 }
+    skip length: 18,  onlyif: lambda { mask_size > 0 && mask_size != 20}
+
+    # Is there a mask defined?
+    def has_data?
+      mask_size > 0
+    end
+
+    # Width of the mask
+    def width
+      right - left
+    end
+
+    # Height of the mask
+    def height
+      bottom - top
+    end
+
+    def relative
+      flags & 0x01
+    end
+
+    def disabled
+      (flags & (0x01 << 1)) > 0
+    end
+
+    def invert
+      (flags & (0x01 << 2)) > 0
+    end
+  end
+end

data/lib/psd/node.rb

@@ -0,0 +1,51 @@
+require_relative 'nodes/ancestry'
+require_relative 'nodes/search'
+
+# 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 Ancestry
+    include Search
+
+    # Default properties that all nodes contain
+    PROPERTIES = [:name, :left, :right, :top, :bottom, :height, :width]
+
+    attr_accessor :parent, :children
+
+    def initialize(layers=[])
+      @children = []
+      layers.each do |layer|
+        layer.parent = self
+        @children << layer
+      end
+    end
+
+    def hidden?
+      !@layer.visible?
+    end
+
+    def visible?
+      @layer.visible?
+    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
+
+    def document_dimensions
+      @parent.document_dimensions
+    end
+  end
+end

data/lib/psd/node_exporting.rb

@@ -0,0 +1,20 @@
+class PSD
+  module NodeExporting #:nodoc:
+    def export_node(node, path)
+      hide_all_nodes
+      node.show!
+      node.lock_to_origin
+
+      width_difference_factor = @header.cols.to_f / node.width
+      height_difference_factor =  @header.rows.to_f / node.height
+      @header.cols, @header.rows = node.width, node.height
+
+      node.scale_path_components(width_difference_factor, height_difference_factor)
+      export path
+    end
+
+    def hide_all_nodes
+      tree.descendants.map(&:hide!)
+    end
+  end
+end

data/lib/psd/node_group.rb

@@ -0,0 +1,67 @@
+require_relative 'node'
+
+class PSD::Node
+  # Represents a group, or folder, in the PSD document. It can have
+  # zero or more children nodes.
+  class Group < PSD::Node
+    include PSD::HasChildren
+    include PSD::Node::ParseLayers
+    include PSD::Node::LockToOrigin
+
+    attr_reader :name, :top, :left, :bottom, :right
+
+    # Parses the descendant tree structure and figures out the bounds
+    # of the layers within this folder.
+    def initialize(folder)
+      @name = folder[:name]
+      @layer = folder[:layer]
+      parse_layers(folder[:layers])
+      get_dimensions
+    end
+
+    # Calculated height of this folder.
+    def rows
+      @right - @left
+    end
+    alias :height :rows
+
+    # Calculated width of this folder.
+    def cols
+      @bottom - @top
+    end
+    alias :width :cols
+
+    # Attempt to translate this folder and all of the descendants.
+    def translate(x=0, y=0)
+      @children.each{ |c| c.translate(x,y) }
+    end
+
+    # Attempt to hide all children of this layer.
+    def hide!
+      @children.each{ |c| c.hide! }
+    end
+
+    # Attempt to show all children of this layer.
+    def show!
+      @children.each{ |c| c.show! }
+    end
+
+    # Export this layer and it's children to a hash recursively.
+    def to_hash
+      super.merge({
+        type: :group,
+        visible: visible?,
+        children: children.map(&:to_hash)
+      })
+    end
+
+    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
+    end
+  end
+end

data/lib/psd/node_layer.rb

@@ -0,0 +1,71 @@
+require_relative 'node'
+
+class PSD::Node
+  class Layer < PSD::Node
+    include PSD::Node::LockToOrigin
+
+    attr_reader :layer
+
+    # Stores a reference to the PSD::Layer
+    def initialize(layer)
+      super([])
+      
+      @layer = layer
+      layer.node = self
+    end
+
+    # Delegates some methods to the PSD::Layer
+    (PROPERTIES + [:text, :ref_x, :ref_y]).each do |meth|
+      define_method meth do
+        @layer.send(meth)
+      end
+
+      define_method "#{meth}=" do |val|
+        @layer.send("#{meth}=", val)
+      end
+    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
+
+    # Attempt to translate the layer.
+    def translate(x=0, y=0)
+      @layer.translate x, y
+    end
+
+    # Attempt to scale the path components of the layer.
+    def scale_path_components(xr, yr)
+      @layer.scale_path_components(xr, yr)
+    end
+
+    # Tries to hide the layer by moving it way off canvas.
+    def hide!
+      # TODO actually mess with the blend modes instead of
+      # just putting things way off canvas
+      return if @hidden_by_kelly
+      translate(100000, 10000)
+      @hidden_by_kelly = true
+    end
+
+    # Tries to re-show the canvas by moving it back to it's original position.
+    def show!
+      if @hidden_by_kelly
+        translate(-100000, -10000)
+        @hidden_by_kelly = false
+      end
+    end
+
+    # Exports this layer to a Hash.
+    def to_hash
+      super.merge({
+        type: :layer,
+        text: @layer.text,
+        ref_x: @layer.reference_point.x,
+        ref_y: @layer.reference_point.y
+      })
+    end
+  end
+end

data/lib/psd/node_root.rb

@@ -0,0 +1,78 @@
+require_relative 'node'
+
+class PSD::Node
+  # Represents the root node of a Photoshop document
+  class Root < PSD::Node
+    include PSD::HasChildren
+    include PSD::Node::ParseLayers
+
+    attr_reader :children
+
+    # Stores a reference to the parsed PSD and builds the
+    # tree hierarchy.
+    def initialize(psd)
+      @psd = psd
+      build_hierarchy
+    end
+
+    # Recursively exports the hierarchy to a Hash
+    def to_hash
+      {
+        children: children.map(&:to_hash),
+        document: {
+          width: document_width,
+          height: document_height
+        }
+      }
+    end
+
+    # Returns the width and height of the entire PSD document.
+    def document_dimensions
+      [@psd.header.width, @psd.header.height]
+    end
+
+    # The width of the full PSD document as defined in the header.
+    def document_width
+      @psd.header.width.to_i
+    end
+
+    # The height of the full PSD document as defined in the header.
+    def document_height
+      @psd.header.height.to_i
+    end
+
+    # The root node has no name since it's not an actual layer or group.
+    def name
+      nil
+    end
+
+    # The depth of the root node is always 0.
+    def depth
+      0
+    end
+
+    private
+
+    def build_hierarchy
+      @children = []
+      result = { layers: [] }
+      parseStack = []
+
+      # First we build the hierarchy
+      @psd.layers.each do |layer|
+        if layer.folder?
+          parseStack << result
+          result = { name: layer.name, layer: layer, layers: [] }
+        elsif layer.folder_end?
+          temp = result
+          result = parseStack.pop
+          result[:layers] << temp
+        else
+          result[:layers] << layer
+        end
+      end
+
+      parse_layers(result[:layers])
+    end
+  end
+end

data/lib/psd/nodes/ancestry.rb

@@ -0,0 +1,82 @@
+class PSD
+  class 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
+
+      # Is this node the root node?
+      def root?
+        self.is_a?(PSD::Node::Root)
+      end
+      alias :is_root? :root?
+
+      # 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
+
+      # Does this node have any children nodes?
+      def has_children?
+        children.length > 0
+      end
+
+      # Inverse of has_children?
+      def is_childless?
+        !has_children?
+      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
+
+      # Does this node have any siblings?
+      def has_siblings?
+        siblings.length > 1
+      end
+
+      # Is this node the only descendant of its parent?
+      def is_only_child?
+        siblings.length == 1
+      end
+
+      # Recursively get all descendant nodes, not including this node.
+      def descendants
+        children + children.map(&:children).flatten
+      end
+
+      # Same as descendants, except it includes this node.
+      def subtree
+        [self] + descendants
+      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
+        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
+    end
+  end
+end

data/lib/psd/nodes/has_children.rb

@@ -0,0 +1,13 @@
+class PSD
+  module HasChildren
+    # Returns all group/folder children of this node.
+    def groups
+      @children.select{ |c| c.is_a?(PSD::Group) }
+    end
+
+    # Returns all layer children of this node.
+    def layers
+      @children.select{ |c| c.is_a?(PSD::Layer) }
+    end
+  end
+end

data/lib/psd/nodes/lock_to_origin.rb

@@ -0,0 +1,7 @@
+class PSD::Node
+  module LockToOrigin #:nodoc:
+    def lock_to_origin
+      translate(-left - 1, -top - 1)
+    end
+  end
+end

data/lib/psd/nodes/parse_layers.rb

@@ -0,0 +1,18 @@
+class PSD::Node
+  module ParseLayers
+    # Organizes the flat layer structure into tree nodes.
+    def parse_layers(layers)
+      @children = []
+      layers.each do |layer|
+        if layer.is_a?(Hash)
+          node = PSD::Node::Group.new(layer)
+        elsif layer.is_a?(PSD::Layer)
+          node = PSD::Node::Layer.new(layer)
+        end
+
+        node.parent = self
+        @children << node
+      end
+    end
+  end
+end