bench9000 0.1

data/vendor/psd.rb/lib/psd/layer_info/typetool.rb

@@ -0,0 +1,165 @@
+# encoding: UTF-8
+require_relative '../layer_info'
+
+class PSD
+  # Parses and provides information about text areas within layers in
+  # the document.
+  class TypeTool < LayerInfo
+    @key = 'TySh'
+    
+    # Parse all of the text data in the layer.
+    def parse
+      version = @file.read_short
+      parse_transform_info
+
+      text_version = @file.read_short
+      descriptor_version = @file.read_int
+
+      @data[:text] = Descriptor.new(@file).parse
+      @data[:text]['EngineData']
+        .encode!('UTF-8', 'MacRoman', invalid: :replace, undef: :replace)
+        .delete!("\000")
+
+      @data[:engine_data] = nil
+      begin
+        parser.parse!
+        @data[:engine_data] = parser.result
+      rescue Exception => e
+        PSD.logger.error e.message
+      end
+
+      warpVersion = @file.read_short
+      descriptor_version = @file.read_int
+
+      @data[:warp] = Descriptor.new(@file).parse
+      [:left, :top, :right, :bottom].each do |pos|
+        @data[pos] = @file.read_int
+      end
+
+      return self
+    end
+
+    # Extracts the text within the text area. In the event that psd-enginedata fails
+    # for some reason, we attempt to extract the text using some rough regex.
+    def text_value
+      if engine_data.nil?
+        # Something went wrong, lets hack our way through.
+        /\/Text \(˛ˇ(.*)\)$/.match(@data[:text]['EngineData'])[1].gsub /\r/, "\n"
+      else
+        engine_data.EngineDict.Editor.Text
+      end
+    end
+    alias :to_s :text_value
+
+    # Gets all of the basic font information for this text area. This assumes that
+    # the first font is the only one you want.
+    def font
+      {
+        name: fonts.first,
+        sizes: sizes,
+        colors: colors,
+        css: to_css
+      }
+    end
+
+    # Returns all fonts listed for this layer, since fonts are defined on a 
+    # per-character basis.
+    def fonts
+      return [] if engine_data.nil?
+      engine_data.ResourceDict.FontSet.map(&:Name)
+    end
+
+    # Return all font sizes for this layer.
+    def sizes
+      return [] if engine_data.nil? || !styles.has_key?('FontSize')
+      styles['FontSize'].uniq
+    end
+
+    # Return all colors used for text in this layer. The colors are returned in RGBA
+    # format as an array of arrays.
+    #
+    # => [[255, 0, 0, 255], [0, 0, 255, 255]]
+    def colors
+      # If the color is opaque black, this field is sometimes omitted.
+      return [[0, 0, 0, 255]] if engine_data.nil? || !styles.has_key?('FillColor')
+      styles['FillColor'].map { |s|
+        values = s['Values'].map { |v| (v * 255).round }
+        values << values.shift # Change ARGB -> RGBA for consistency
+      }.uniq
+    end
+
+    def engine_data
+      @data[:engine_data]
+    end
+
+    def styles
+      return {} if engine_data.nil?
+
+      @styles ||= (
+        data = engine_data.EngineDict.StyleRun.RunArray.map do |r|
+          r.StyleSheet.StyleSheetData
+        end
+
+        Hash[data.reduce({}) { |m, o|
+          o.each do |k, v|
+            (m[k] ||= []) << v
+          end
+
+          m
+        }.map { |k, v|
+          [k, v.uniq]
+        }]
+      )
+    end
+
+    def parser
+      @parser ||= PSD::EngineData.new(@data[:text]['EngineData'])
+    end
+
+    # Creates the CSS string and returns it. Each property is newline separated
+    # and not all properties may be present depending on the document.
+    #
+    # Colors are returned in rgba() format and fonts may include some internal
+    # Photoshop fonts.
+    def to_css      
+      definition = {
+        'font-family' => fonts.join(', '),
+        'font-size' => "#{sizes.first}pt",
+        'color' => "rgba(#{colors.first.join(', ')})"
+      }
+
+      css = []
+      definition.each do |k, v|
+        css << "#{k}: #{v};"
+      end
+
+      css.join("\n")
+    end
+
+    def to_hash
+      {
+        value:      text_value,
+        font:       font,
+        left:       left,
+        top:        top,
+        right:      right,
+        bottom:     bottom,
+        transform:  transform
+      }
+    end
+
+    def method_missing(method, *args, &block)
+      return @data[method] if @data.has_key?(method)
+      return super
+    end
+
+    private
+
+    def parse_transform_info
+      @data[:transform] = {}
+      [:xx, :xy, :yx, :yy, :tx, :ty].each do |t|
+        @data[:transform][t] = @file.read_double
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/layer_info/unicode_name.rb

@@ -0,0 +1,17 @@
+require_relative '../layer_info'
+
+class PSD
+  class UnicodeName < LayerInfo
+    @key = 'luni'
+
+    def parse
+      pos = @file.tell
+      @data = @file.read_unicode_string
+
+      # The name seems to be padded with null bytes. This is the easiest solution.
+      @file.seek pos + @length
+
+      return self
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/layer_info/vector_mask.rb

@@ -0,0 +1,25 @@
+require_relative '../layer_info'
+
+class PSD
+  class VectorMask < LayerInfo
+    @key = 'vmsk'
+
+    attr_reader :invert, :not_link, :disable, :paths
+
+    def parse
+      version = @file.read_int
+      tag = @file.read_int
+
+      @invert = tag & 0x01
+      @not_link = (tag & (0x01 << 1)) > 0
+      @disable = (tag & (0x01 << 2)) > 0
+
+      num_records = (@length - 8) / 26
+      
+      @paths = []
+      num_records.times do
+        @paths << PathRecord.new(@file)
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/layer_info/vector_mask_2.rb

@@ -0,0 +1,10 @@
+require_relative 'vector_mask'
+
+class PSD
+  # Identical to VectorMask, except with a different key. This
+  # exists in Photoshop >= CS6. If this key exists, then there
+  # is also a vscg key.
+  class VectorMask2 < VectorMask
+    @key = 'vsms'
+  end
+end

data/vendor/psd.rb/lib/psd/layer_info/vector_stroke.rb

@@ -0,0 +1,12 @@
+require_relative '../layer_info'
+
+class PSD
+  class VectorStroke < LayerInfo
+    @key = 'vstk'
+
+    def parse
+      version = @file.read_int
+      @data = Descriptor.new(@file).parse
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/layer_info/vector_stroke_content.rb

@@ -0,0 +1,15 @@
+require_relative '../layer_info'
+
+class PSD
+  class VectorStrokeContent < LayerInfo
+    @key = 'vscg'
+
+    attr_reader :key
+    
+    def parse
+      key = @file.read_string(4)
+      version = @file.read_int
+      @data = Descriptor.new(@file).parse
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/layer_mask.rb

@@ -0,0 +1,129 @@
+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.
+    def initialize(file, header, options)
+      @file = file
+      @header = header
+      @options = options
+
+      @layers = []
+      @merged_alpha = false
+      @global_mask = nil
+      @extras = []
+    end
+
+    # Allows us to skip this section because it starts with the length of the section
+    # stored as an integer.
+    def skip
+      @file.seek @file.read_int, IO::SEEK_CUR
+      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.
+    def parse
+      start_section
+
+      mask_size = @file.read_int
+      finish = @file.tell + mask_size
+
+      return self if mask_size <= 0
+
+      layer_info_size = Util.pad2(@file.read_int)
+
+      if layer_info_size > 0
+        layer_count = @file.read_short
+
+        if layer_count < 0
+          layer_count = layer_count.abs
+          @merged_alpha = true
+        end
+
+        if layer_count * (18 + 6 * @header.channels) > layer_info_size
+          raise "Unlikely number of layers parsed: #{layer_count}"
+        end
+
+        @layer_section_start = @file.tell
+        layer_count.times do
+          @layers << PSD::Layer.new(@file, @header).parse
+        end
+
+        layers.each do |layer|
+          layer.parse_channel_image(@header)
+        end
+      end
+
+      # Layers are parsed in reverse order
+      layers.reverse!
+      group_layers
+
+      parse_global_mask
+
+      # Ensure we're at the end of this section
+      @file.seek finish
+      end_section
+
+      return self
+    end
+
+    # Export the mask and all the children layers to a file.
+    def export(outfile)
+      if @layers.size == 0
+        # No data, just read whatever's here.
+        return outfile.write @file.read(@section_end[:all] - start_of_section)
+      end
+
+      # Read the initial mask data since it won't change
+      outfile.write @file.read(@layer_section_start - @file.tell)
+
+      @layers.reverse.each do |layer|
+        layer.export(outfile)
+      end
+
+      outfile.write @file.read(end_of_section - @file.tell)
+    end
+
+    private
+
+    def group_layers
+      group_layer = nil
+      layers.each do |layer|
+        if layer.folder?
+          group_layer = layer
+        elsif layer.folder_end?
+          group_layer = nil
+        else
+          layer.group_layer = layer
+        end
+      end
+    end
+
+    def parse_global_mask
+      length = @file.read_int
+      
+      PSD.logger.debug "Global Mask: length = #{length}"
+      return if length <= 0
+
+      mask_end = @file.tell + length
+      
+      @global_mask = {}
+      @global_mask[:overlay_color_space] = @file.read_short
+      @global_mask[:color_components] = 4.times.map { |i| @file.read_short >> 8 }
+      @global_mask[:opacity] = @file.read_short / 16.0
+
+      # 0 = color selected, 1 = color protected, 128 = use value per layer
+      @global_mask[:kind] = @file.read(1).bytes.to_a[0]
+
+      PSD.logger.debug @global_mask
+
+      # Filler zeros
+      @file.seek mask_end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/lazy_execute.rb

@@ -0,0 +1,60 @@
+class PSD
+  # Used for lazily executing methods on demand
+  class LazyExecute
+    def initialize(obj, file)
+      @obj = obj
+      @file = file
+
+      @start_pos = @file.tell
+      @loaded = false
+      @load_method = nil
+      @load_args = []
+      @passthru = []
+
+      PSD.logger.debug "Marked #{@obj.class.name} at position #{@start_pos} for lazy execution"
+    end
+
+    def now(method, *args, &block)
+      PSD.logger.debug "Executing #{@obj.class.name}##{method} now"
+      @obj.send(method, *args, &block)
+      return self
+    end
+
+    def later(method, *args)
+      @load_method = method
+      @load_args = args
+      return self
+    end
+
+    def ignore(*args)
+      @passthru += args
+      return self
+    end
+
+    def loaded?
+      @loaded
+    end
+
+    def method_missing(method, *args, &block)
+      load! if !loaded? && !@passthru.include?(method.to_sym)
+      @obj.send(method, *args, &block)
+    end
+
+    def inspect
+      "<PSD::LazyExecute @obj=#{@obj.class.name}, @pos=#{@start_pos}, @load_method=:#{@load_method}>"
+    end
+
+    private
+
+    def load!
+      PSD.logger.debug "Lazily executing #{@obj.class.name}##{@load_method}"
+      orig_pos = @file.tell
+      @file.seek @start_pos
+
+      @obj.send(@load_method, *@load_args)
+
+      @file.seek orig_pos
+      @loaded = true
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/logger.rb

@@ -0,0 +1,40 @@
+require 'logger'
+
+class PSD
+  module Logger
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      attr_reader :debug
+      attr_writer :logger
+
+      def debug=(enabled)
+        @debug = enabled
+        @logger = nil
+      end
+
+      def logger
+        return @logger if @logger
+
+        if debug || ENV['PSD_DEBUG']
+          @logger = ::Logger.new(STDOUT)
+          @logger.formatter = proc do |severity, datetime, progname, msg|
+            "#{severity}: #{msg}\n"
+          end
+        else
+          @logger = DisabledLogger.new
+        end
+
+        return @logger
+      end
+    end
+  end
+
+  class DisabledLogger
+    def method_missing(method, *args, &block)
+      # silence
+    end
+  end
+end