psd 0.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c0aedda5ca28cfc042d4b1ade1edb805c8839fe7
+  data.tar.gz: 4b40477a1bd67e4eb2f831eb90c01af7ee366635
+SHA512:
+  metadata.gz: 1c266acc7f5017d7e16312f9c75ec38a2b806f3ca32987105fe32e156fbc55484db2dcba41b5786c95fc3fd70df8ff032615aa8b83100ab72a03130fe7de4a3a
+  data.tar.gz: 51a2da94d3778c56dc2feec7a7b14d8524343224515dd9a656e8a65475d5149145d4dad793331a97b0dfa814eef005aa687ae74862402f9c27d12412129d58c1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', cli: '--color' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 LayerVault
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,161 @@
+# PSD.rb
+
+![](https://circleci.com/gh/layervault/psd.rb.png?circle-token=ad8a75fdd86f595e0926a963179a3a621d564c6e)
+
+A general purpose Photoshop file parser written in Ruby. It allows you to work with a Photoshop document in a manageable tree structure and find out important data such as:
+
+* Document structure
+* Document size
+* Layer/folder size + positioning
+* Layer/folder names
+* Layer/folder visibility and opacity
+* Font data (via [psd-enginedata](https://github.com/layervault/psd-enginedata))
+  * Text area contents
+  * Font names
+  * Font sizes
+* Color mode and bit-depth
+* Vector mask data
+* Flattened image data
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'psd'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install psd
+
+## Usage
+
+**Loading a PSD**
+
+``` ruby
+require 'psd'
+
+psd = PSD.new('/path/to/file.psd')
+psd.parse!
+```
+
+**Traversing the Document**
+
+To access the document as a tree structure, use `psd.tree` to get the root node. From there, you can traverse the tree using any of these methods:
+
+* `root`: get the root node from anywhere in the tree
+* `ancestors`: get all ancestors in the path of this node (excluding the root)
+* `siblings`: get all sibling tree nodes including the current one (e.g. all layers in a folder)
+* `descendants`: get all descendant nodes not including the current one
+* `subtree`: same as descendants but starts with the current node
+* `depth`: calculate the depth of the current node
+
+For any of the traversal methods, you can also retrieves folder or layer nodes only by appending `_layers` or `_groups` to the method. For example:
+
+``` ruby
+psd.tree.descendant_layers
+```
+
+**Accessing Layer Data**
+
+To get data such as the name or dimensions of a layer:
+
+``` ruby
+psd.tree.descendant_layers.first.name
+psd.tree.descendant_layers.first.width
+```
+
+PSD files also store various pieces of information in "layer info" blocks. Which blocks a layer has varies from layer-to-layer, but to access them you can do:
+
+``` ruby
+psd.tree.descendant_layers.first.type.font
+
+# Returns
+{:name=>"HelveticaNeue-Light",
+ :sizes=>[33.0],
+ :colors=>[[255, 19, 120, 98]],
+ :css=>
+  "font-family: \"HelveticaNeue-Light\", \"AdobeInvisFont\", \"MyriadPro-Regular\";\nfont-size: 33.0pt;\ncolor: rgba(19, 120, 98, 255);"}
+```
+
+**Exporting Data**
+
+When working with the tree structure, you can recursively export any node to a Hash.
+
+``` ruby
+pp psd.tree.to_hash
+```
+
+Which produces something like:
+
+``` ruby
+{:children=>
+  [{:type=>:group,
+    :visible=>false,
+    :opacity=>1.0,
+    :blending_mode=>"normal",
+    :name=>"Version D",
+    :left=>0,
+    :right=>900,
+    :top=>0,
+    :bottom=>600,
+    :height=>900,
+    :width=>600,
+    :children=>
+     [{:type=>:layer,
+       :visible=>true,
+       :opacity=>1.0,
+       :blending_mode=>"normal",
+       :name=>"Make a change and save.",
+       :left=>275,
+       :right=>636,
+       :top=>435,
+       :bottom=>466,
+       :height=>31,
+       :width=>361,
+       :text=>
+        {:value=>"Make a change and save.",
+         :font=>
+          {:name=>"HelveticaNeue-Light",
+           :sizes=>[33.0],
+           :colors=>[[255, 19, 120, 98]],
+           :css=>
+            "font-family: \"HelveticaNeue-Light\", \"AdobeInvisFont\", \"MyriadPro-Regular\";\nfont-size: 33.0pt;\ncolor: rgba(19, 120, 98, 255);"},
+         :left=>0,
+         :top=>0,
+         :right=>0,
+         :bottom=>0,
+         :transform=>
+          {:xx=>1.0, :xy=>0.0, :yx=>0.0, :yy=>1.0, :tx=>456.0, :ty=>459.0}},
+       :ref_x=>264.0,
+       :ref_y=>-3.0}]
+  }],
+:document=>{:width=>900, :height=>600}}
+```
+
+You can also export the PSD to a flattened image. Please note that, at this time, not all image modes + depths are supported.
+
+``` ruby
+png = psd.image.to_png # reference to PNG data
+psd.image.save_as_png 'path/to/output.png' # writes PNG to disk
+```
+
+## To-do
+
+There are a few features that are currently missing from PSD.rb.
+
+* Global layer mask
+* Individual layer image exporting
+* More image modes + depths for image exporting
+* A few layer info blocks
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/circle.yml

@@ -0,0 +1,6 @@
+machine:
+  ruby:
+    version: 2.0.0-p195
+test:
+  override:
+    - rspec

data/examples/export.rb

@@ -0,0 +1,7 @@
+require './lib/psd'
+
+psd = PSD.new('examples/images/example.psd')
+psd.parse!
+
+
+psd.export_node psd.tree.children.last.children[1], "asset.psd"

data/examples/export_image.rb

@@ -0,0 +1,12 @@
+require 'benchmark'
+require './lib/psd'
+
+psd = PSD.new('examples/images/example.psd')
+
+results = Benchmark.measure "Image exporting" do
+  psd.image.save_as_png 'output.png'
+end
+
+puts "Flattened image exported to ./output.png\n"
+puts Benchmark::CAPTION
+puts results.to_s

data/examples/export_text_data.rb

@@ -0,0 +1,13 @@
+require './lib/psd'
+
+file = ARGV[0] || 'examples/images/example.psd'
+psd = PSD.new(file)
+psd.parse!
+
+outfile = './enginedata'
+psd.tree.descendant_layers.each do |l|
+  next unless l.layer.adjustments[:type]
+  File.write(outfile, l.layer.adjustments[:type].engine_data)
+  puts "Exported to #{outfile}"
+  exit
+end

data/examples/parse.rb

@@ -0,0 +1,31 @@
+require 'benchmark'
+require './lib/psd'
+
+psd = nil
+file = ARGV[0] || 'examples/images/example.psd'
+results = Benchmark.measure "PSD parsing" do
+  psd = PSD.new(file)
+  psd.parse!
+end
+
+puts "\nVisible Layers:\n===================="
+psd.layers.each do |layer|
+  next if layer.folder? || layer.hidden?
+
+  puts "Name: #{layer.name}"
+  puts "Position: top = #{layer.top}, left = #{layer.left}"
+  puts "Size: width = #{layer.width}, height = #{layer.height}"
+  puts "Mask: width = #{layer.mask.width}, height = #{layer.mask.height}"
+  puts "Reference point: #{layer.ref_x}, #{layer.ref_y}"
+
+  puts ""
+end
+
+puts "\nPSD Info:\n===================="
+puts "#{psd.width}x#{psd.height} #{psd.header.mode_name}"
+puts "#{psd.resources.size} resources parsed"
+puts "#{psd.layers.size} layers, #{psd.folders.size} folders"
+
+puts "\nBenchmark Results (seconds):\n===================="
+puts " "*7 + Benchmark::CAPTION
+puts "parse: " + results.to_s

data/examples/path.rb

@@ -0,0 +1,7 @@
+require './lib/psd'
+require 'pp'
+
+psd = PSD.new('examples/images/example.psd')
+psd.parse!
+
+pp psd.tree.children_at_path("Version D/Version E/Version F").first.to_hash

data/examples/tree.rb

@@ -0,0 +1,8 @@
+require './lib/psd'
+require 'pp'
+
+file = ARGV[0] || 'examples/images/example.psd'
+psd = PSD.new(file)
+psd.parse!
+
+pp psd.tree.to_hash

data/examples/unimplemented_info.rb

@@ -0,0 +1,9 @@
+require './lib/psd'
+require 'pp'
+
+file = ARGV[0] || 'examples/images/example.psd'
+psd = PSD.new(file)
+psd.parse!
+
+puts '-> Layer Info Keys'
+pp PSD.keys.uniq

data/lib/psd.rb

@@ -0,0 +1,145 @@
+require "bindata"
+require "psd/enginedata"
+
+require_relative 'psd/section'
+
+dir_root = File.dirname(File.absolute_path(__FILE__)) + '/psd'
+[
+  '/image_formats/*',
+  '/image_modes/*',
+  '/image_exports/*',
+  '/nodes/*',
+  '/layer_info/**/*',
+  '/**/*'
+].each do |path|
+  Dir.glob(dir_root + path) { |file| require file if File.file?(file) }
+end
+
+# A general purpose parser for Photoshop files. PSDs are broken up in to 4 logical sections:
+# the header, resources, the layer mask (including layers), and the preview image. We parse
+# each of these sections in order.
+class PSD
+  include Helpers
+  include NodeExporting
+
+  # Just used to track what layer info keys we didn't parse in this file for development purposes.
+  def self.keys; @@keys; end
+  @@keys = []
+
+  DEFAULTS = {
+    parse_image: false,
+    parse_layer_images: false
+  }
+
+  attr_reader :file
+
+  # Create and store a reference to our PSD file
+  def initialize(file, opts={})
+    @file = PSD::File.new(file, 'rb')
+    @file.seek 0 # If the file was previously used and not closed
+
+    @opts = DEFAULTS.merge(opts)
+    @header = nil
+    @resources = nil
+    @layer_mask = nil
+    @parsed = false
+  end
+
+  # There is a specific order that must be followed when parsing
+  # the PSD. Sections can be skipped if needed. This method will
+  # parse all sections of the PSD.
+  def parse!
+    header
+    resources
+    layer_mask
+    image if @opts[:parse_image]
+    
+    @parsed = true
+
+    return true
+  end
+
+  # Has our PSD been parsed yet?
+  def parsed?
+    @parsed
+  end
+
+  # Get the Header, parsing it if needed.
+  def header
+    @header ||= Header.read(@file)
+  end
+
+  # Get the Resources section, parsing if needed.
+  def resources
+    return @resources.data unless @resources.nil?
+
+    ensure_header
+
+    @resources = Resources.new(@file)
+    @resources.parse
+
+    return @resources.data
+  end
+
+  # Get the LayerMask section. Ensures the header and resources
+  # have been parsed first since they are required.
+  def layer_mask
+    ensure_header
+    ensure_resources
+
+    @layer_mask ||= LayerMask.new(@file, @header).parse
+  end
+
+  # Get the full size flattened preview Image.
+  def image
+    ensure_header
+    ensure_resources
+    ensure_layer_mask
+
+    @image ||= Image.new(@file, @header).parse
+  end
+
+  # Export the current file to a new PSD. This may or may not work.
+  def export(file)
+    parse! unless parsed?
+
+    # Create our file for writing
+    outfile = File.open(file, 'w')
+
+    # Reset the file pointer
+    @file.seek 0
+    @header.write outfile
+    @file.seek @header.num_bytes, IO::SEEK_CUR
+
+    # Nothing in the header or resources we want to bother with changing
+    # right now. Write it straight to file.
+    outfile.write @file.read(@resources.end_of_section - @file.tell)
+
+    # Now, the changeable part. Layers and masks.
+    layer_mask.export(outfile)
+
+    # And the rest of the file (merged image data)
+    outfile.write @file.read
+    outfile.flush
+  end
+
+  private
+
+  def ensure_header
+    header # Header is always required
+  end
+
+  def ensure_resources
+    return unless @resources.nil?
+    
+    @resources = Resources.new(@file)
+    @resources.skip
+  end
+
+  def ensure_layer_mask
+    return unless @layer_mask.nil?
+
+    @layer_mask = LayerMask.new(@file, @header)
+    @layer_mask.skip
+  end
+end