bench9000 0.1

data/vendor/psd.rb/lib/psd/mask.rb

@@ -0,0 +1,74 @@
+class PSD
+  class Mask
+    attr_reader :size, :top, :left, :bottom, :right, :default_color
+
+    def self.read(file)
+      mask = Mask.new(file)
+      mask.parse
+
+      mask
+    end
+
+    def initialize(file)
+      @file = file
+      @top = 0
+      @left = 0
+      @bottom = 0
+      @right = 0
+    end
+
+    def parse
+      @size = @file.read_int
+      return if @size == 0
+
+      @mask_end = @file.tell + @size
+
+      @top = @file.read_int
+      @left = @file.read_int
+      @bottom = @file.read_int
+      @right = @file.read_int
+
+      @default_color = @file.read_byte
+      @flags = @file.read_byte
+
+      @file.seek @mask_end # Useless info/padding
+    end
+
+    def width
+      right - left
+    end
+
+    def height
+      bottom - top
+    end
+
+    def relative
+      (@flags & 0x01) > 0
+    end
+
+    def disabled
+      (@flags & (0x01 << 1)) > 0
+    end
+
+    def invert
+      (@flags & (0x01 << 2)) > 0
+    end
+
+    def to_hash
+      return {} if @size == 0
+
+      {
+        top: top,
+        left: left,
+        bottom: bottom,
+        right: right,
+        width: width,
+        height: height,
+        default_color: default_color,
+        relative: relative,
+        disabled: disabled,
+        invert: invert
+      }
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/node.rb

@@ -0,0 +1,70 @@
+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 ParseLayers
+    include Ancestry
+    include Search
+    include BuildPreview
+
+    # Default properties that all nodes contain
+    PROPERTIES = [:name, :left, :right, :top, :bottom, :height, :width]
+
+    attr_accessor :parent, :children, :layer, :force_visible, :top, :left
+
+    def initialize(layers=[])
+      parse_layers(layers)
+
+      @force_visible = nil
+      @top = @layer.top
+      @left = @layer.left
+    end
+
+    def hidden?
+      !visible?
+    end
+
+    def visible?
+      return false if @layer.clipped? && !next_sibling.visible?
+      force_visible.nil? ? @layer.visible? : force_visible
+    end
+
+    def psd
+      parent.psd
+    end
+
+    def layer?
+      is_a?(PSD::Node::Layer)
+    end
+
+    def group?
+      is_a?(PSD::Node::Group) || 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
+
+    def document_dimensions
+      @parent.document_dimensions
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+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::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]
+      
+      super(folder[:layers])
+      get_dimensions
+    end
+
+    # Calculated height of this folder.
+    def rows
+      @bottom - @top
+    end
+    alias :height :rows
+
+    # Calculated width of this folder.
+    def cols
+      @right - @left
+    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
+
+    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,
+        visible: visible?,
+        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
+
+    private
+
+    def get_dimensions
+      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/vendor/psd.rb/lib/psd/node_layer.rb

@@ -0,0 +1,81 @@
+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)
+      @layer = layer
+      layer.node = self
+
+      super([])
+    end
+
+    # Delegates some methods to the PSD::Layer
+    [: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
+
+    # 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
+
+    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: @layer.reference_point.x,
+        ref_y: @layer.reference_point.y,
+        mask: @layer.mask.to_hash,
+        image: {
+          width: @layer.image.width,
+          height: @layer.image.height,
+          channels: @layer.channels_info
+        }
+      })
+    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

data/vendor/psd.rb/lib/psd/node_root.rb

@@ -0,0 +1,93 @@
+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_accessor :children
+    attr_reader :psd
+
+    # 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,
+          resources: {
+            layer_comps: @psd.layer_comps,
+            guides: @psd.guides,
+            slices: @psd.slices
+          }
+        }
+      }
+    end
+
+    # Returns the width and height of the entire PSD document.
+    def document_dimensions
+      [document_width, document_height]
+    end
+
+    # The width of the full PSD document as defined in the header.
+    def document_width
+      @psd.header.width.to_i
+    end
+    alias_method :width, :document_width
+
+    # The height of the full PSD document as defined in the header.
+    def document_height
+      @psd.header.height.to_i
+    end
+    alias_method :height, :document_height
+
+    # 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
+
+    [:top, :right, :bottom, :left].each do |meth|
+      define_method(meth) { 0 }
+    end
+
+    def opacity; 255; end
+    def fill_opacity; 255; 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/vendor/psd.rb/lib/psd/nodes/ancestry.rb

@@ -0,0 +1,98 @@
+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 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
+
+      def next_sibling
+        return nil if parent.nil?
+        index = siblings.index(self)
+        siblings[index + 1]
+      end
+
+      def prev_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
+
+      # Is this node the only descendant of its parent?
+      def only_child?
+        siblings.length == 1
+      end
+
+      # Recursively get all descendant nodes, not including this node.
+      def descendants
+        children.map(&:subtree).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 path
+        (ancestors.map(&:name) + [name]).join('/')
+      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