bench9000 0.1

data/vendor/psd.rb/spec/lazy_execute_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe PSD::LazyExecute do
+  before(:each) do
+    @psd = PSD.new('spec/files/pixel.psd')
+  end
+
+  it 'initializes correctly' do
+    expect(@psd.image).to be_an_instance_of(PSD::LazyExecute)
+    expect(@psd.image).to_not be_loaded
+    expect(@psd.image.instance_variable_get(:@obj)).to be_an_instance_of(PSD::Image)
+    expect(@psd.image.instance_variable_get(:@start_pos)).to eq @psd.file.tell
+    expect(@psd.image.instance_variable_get(:@load_method)).to eq :parse
+  end
+
+  it 'loads when accessed the first time' do
+    @psd.image.to_png
+    expect(@psd.image).to be_loaded
+  end
+end

data/vendor/psd.rb/spec/locked_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe 'Locked' do
+  it "should parse locked layer info" do
+    psd = PSD.new('spec/files/locked.psd')
+    psd.parse!
+
+    expect(psd.tree.children[0].position_locked?).to eq(true)
+    expect(psd.tree.children[0].all_locked?).to eq(true)
+    expect(psd.tree.children[0].composite_locked?).to eq(true)
+    expect(psd.tree.children[0].transparency_locked?).to eq(true)
+    
+    expect(psd.tree.children[1].position_locked?).to eq(true)
+    expect(psd.tree.children[1].all_locked?).to eq(false)
+    expect(psd.tree.children[1].composite_locked?).to eq(false)
+    expect(psd.tree.children[1].transparency_locked?).to eq(false)
+    
+    expect(psd.tree.children[2].position_locked?).to eq(false)
+    expect(psd.tree.children[2].all_locked?).to eq(false)
+    expect(psd.tree.children[2].composite_locked?).to eq(true)
+    expect(psd.tree.children[2].transparency_locked?).to eq(false)
+
+    expect(psd.tree.children[3].position_locked?).to eq(false)
+    expect(psd.tree.children[3].all_locked?).to eq(false)
+    expect(psd.tree.children[3].composite_locked?).to eq(false)
+    expect(psd.tree.children[3].transparency_locked?).to eq(true)
+
+    expect(psd.tree.children[4].position_locked?).to eq(true)
+    expect(psd.tree.children[4].all_locked?).to eq(false)
+    expect(psd.tree.children[4].composite_locked?).to eq(true)
+    expect(psd.tree.children[4].transparency_locked?).to eq(false)
+
+    expect(psd.tree.children[5].position_locked?).to eq(true)
+    expect(psd.tree.children[5].all_locked?).to eq(false)
+    expect(psd.tree.children[5].composite_locked?).to eq(false)
+    expect(psd.tree.children[5].transparency_locked?).to eq(true)
+
+    expect(psd.tree.children[6].position_locked?).to eq(false)
+    expect(psd.tree.children[6].all_locked?).to eq(false)
+    expect(psd.tree.children[6].composite_locked?).to eq(false)
+    expect(psd.tree.children[6].transparency_locked?).to eq(false)
+
+    expect(psd.tree.children[7].position_locked?).to eq(true)
+    expect(psd.tree.children[7].all_locked?).to eq(true)
+    expect(psd.tree.children[7].composite_locked?).to eq(true)
+    expect(psd.tree.children[7].transparency_locked?).to eq(true)
+
+    expect(psd.tree.children[7].children[0].position_locked?).to eq(false)
+    expect(psd.tree.children[7].children[0].all_locked?).to eq(false)
+    expect(psd.tree.children[7].children[0].composite_locked?).to eq(false)
+    expect(psd.tree.children[7].children[0].transparency_locked?).to eq(false)
+
+    expect(psd.tree.children[7].children[1].position_locked?).to eq(true)
+    expect(psd.tree.children[7].children[1].all_locked?).to eq(true)
+    expect(psd.tree.children[7].children[1].composite_locked?).to eq(true)
+    expect(psd.tree.children[7].children[1].transparency_locked?).to eq(true)
+
+    expect(psd.tree.children[7].children[1].children[0].position_locked?).to eq(true)
+    expect(psd.tree.children[7].children[1].children[0].all_locked?).to eq(false)
+    expect(psd.tree.children[7].children[1].children[0].composite_locked?).to eq(false)
+    expect(psd.tree.children[7].children[1].children[0].transparency_locked?).to eq(false)
+
+    expect(psd.tree.children[8].position_locked?).to eq(true)
+    expect(psd.tree.children[8].all_locked?).to eq(false)
+    expect(psd.tree.children[8].composite_locked?).to eq(false)
+    expect(psd.tree.children[8].transparency_locked?).to eq(true)
+
+    expect(psd.tree.children[9].position_locked?).to eq(true)
+    expect(psd.tree.children[9].all_locked?).to eq(true)
+    expect(psd.tree.children[9].composite_locked?).to eq(true)
+    expect(psd.tree.children[9].transparency_locked?).to eq(true)
+
+    expect(psd.tree.children[12].position_locked?).to eq(false)
+    expect(psd.tree.children[12].all_locked?).to eq(false)
+    expect(psd.tree.children[12].composite_locked?).to eq(false)
+    expect(psd.tree.children[12].transparency_locked?).to eq(false)
+  end
+end

data/vendor/psd.rb/spec/parsing_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe 'Parsing' do
+  before(:each) do
+    @psd = PSD.new('spec/files/example.psd')
+  end
+
+  it "should parse without error" do
+    @psd.parse!
+    expect(@psd).to be_parsed
+  end
+
+  describe 'Header' do
+    before(:each) do
+      @psd.parse!
+    end
+
+    it "should contain data" do
+      expect(@psd.header).not_to be_nil
+    end
+
+    it "should be the proper version" do
+      expect(@psd.header.version).to eq(1)
+    end
+
+    it "should have the proper number of channels" do
+      expect(@psd.header.channels).to eq(3)
+    end
+
+    it "should parse the proper document dimensions" do
+      expect(@psd.header.width).to eq(900)
+      expect(@psd.header.height).to eq(600)
+    end
+
+    it "should correctly parse the color mode" do
+      expect(@psd.header.mode).to eq(3)
+      expect(@psd.header.mode_name).to eq('RGBColor')
+    end
+  end
+
+  describe 'Resources' do
+    before(:each) do
+      @psd.parse!
+    end
+
+    it "should contain data" do
+      expect(@psd.resources).not_to be_nil
+      expect(@psd.resources.data).to be_an_instance_of(Hash)
+      expect(@psd.resources.data.size).to be >= 1
+    end
+
+    it "should be of type 8BIM" do
+      @psd.resources.data.each { |id, r| expect(r.type).to eq('8BIM') }
+    end
+
+    it "should have an ID" do
+      @psd.resources.data.each do |id, r|
+        expect(r.id).to_not be_nil
+      end
+    end
+  end
+
+  describe 'Layer Mask' do
+    before(:each) do
+      @psd.parse!
+    end
+
+    it "should contain data" do
+      expect(@psd.layer_mask).to_not be_nil
+      expect(@psd.layer_mask).to be_an_instance_of(PSD::LayerMask)
+    end
+
+    it "should contain layers" do
+      expect(@psd.layer_mask.layers.size).to be > 0
+    end
+
+    # The test file is actually missing the global mask. Need a new test file
+    # with it present.
+    # it "should contain the global layer mask data" do
+    #   expect(@psd.layer_mask.global_mask).to_not be_nil
+    #   expect(@psd.layer_mask.global_mask).to include :overlay_color_space
+    #   expect(@psd.layer_mask.global_mask).to include :color_components
+    #   expect(@psd.layer_mask.global_mask).to include opacity: 1.0
+    # end
+  end
+
+  describe 'Layers' do
+    before(:each) do
+      @psd.parse!
+    end
+
+    it "should contain each layer" do
+      expect(@psd.layer_mask.layers.size).to eq(15)
+      expect(@psd.layers).to be @psd.layer_mask.layers
+      @psd.layers.each { |l| expect(l).to be_an_instance_of(PSD::Layer) }
+    end
+
+    it "should have a name" do
+      expect(@psd.layers.first.name).to eq('Version C')
+    end
+
+    it "should properly identify folders" do
+      expect(@psd.layers.first).to be_folder
+      expect(@psd.layers.select { |l| l.name == 'Matte' }.first).not_to be_folder
+    end
+
+    it "should properly detect visibility" do
+      expect(@psd.layers.first).not_to be_visible
+      expect(
+        @psd
+          .layers
+          .select { |l| l.name == 'Version A' }.first
+      ).to be_visible
+    end
+
+    it "should properly calculate dimensions" do
+      layer = @psd.layers.select { |l| l.name == 'Logo_Glyph' }.last
+      expect(layer.width).to eq(142)
+      expect(layer.height).to eq(179)
+    end
+
+    it "should properly calculate coordinates" do
+      layer = @psd.layers.select { |l| l.name == 'Logo_Glyph' }.last
+      expect(layer.left).to eq(379)
+      expect(layer.top).to eq(210)
+    end
+
+    it "should have a blend mode" do
+      blend_mode = @psd.layers.select { |l| l.name == 'Version A' }.last.blend_mode
+      expect(blend_mode).to_not be_nil
+      expect(blend_mode.mode).to eq('normal')
+      expect(blend_mode.opacity).to eq(255)
+      expect(blend_mode.opacity_percentage).to eq(100)
+      expect(blend_mode.visible).to be true
+    end
+
+    it "should parse all layer comps" do
+      expect(@psd.layer_comps.size).to eq(3)
+      expect(@psd.layer_comps.map { |c| c[:name] }).to eq([
+        'Version A',
+        'Version B',
+        'Version C'
+      ])
+
+      @psd.layer_comps.each do |c|
+        expect(c[:id]).to be > 0
+      end
+    end
+  end
+  
+  describe 'Blend Modes' do
+    before(:each) do
+      @psd = PSD.new('spec/files/blendmodes.psd')
+      @psd.parse!
+    end
+
+    it "should parse all blend modes" do
+      @psd.layers.each do |layer|
+        expect(layer.blend_mode.mode).to eq layer.name
+      end      
+    end
+  end  
+end

data/vendor/psd.rb/spec/psd_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe 'PSD' do
+  let(:filename) { 'spec/files/example.psd' }
+
+	it 'should open a file without a block' do
+    psd = PSD.new(filename)
+    expect(psd).to_not be_parsed
+    expect(psd).to be_an_instance_of(PSD)
+	end
+
+  it 'should raise an exception if using open without a block' do
+    expect {
+      PSD.open(filename)  
+    }.to raise_error
+  end
+
+  it 'should refuse to open a bad filename' do
+    expect { PSD.open('') }.to raise_error
+  end
+
+  it 'should open a file and feed it to a block' do
+    PSD.open(filename) do |psd|
+      expect(psd).to be_parsed
+      expect(psd).to be_an_instance_of(PSD)
+    end
+  end
+
+  # We have to use #should syntax here because the DSL binds
+  # the block to the PSD instance.
+  it 'should open a file and feed it to a block DSL style' do
+    PSD.open(filename) do
+      parsed?.should == true
+      is_a?(PSD).should == true
+    end
+  end
+end

data/vendor/psd.rb/spec/slices_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe 'Slices' do
+  describe "Handle file with slice properly" do
+    it "should successfully parse a the PSD file of version 7 or above and has slices" do
+      psd = PSD.new('spec/files/slices.psd')
+      psd.parse!
+
+      # File should parse
+      expect(psd).to be_parsed
+
+      # Slices should not be nil
+      expect(psd.resources[:slices]).to_not be_nil
+
+      # slices version should be above 6
+      expect(psd.resources[:slices].data.version).to be > 6
+
+      # Bounds of each slice should not be nil
+      psd.resources[:slices].data.to_a.each do |slice|
+        expect(slice).to_not be_nil
+        expect(slice[:bounds]).to_not be_nil
+      end
+    end
+
+    it "should successfully parse a the PSD file of version 6 and has slices" do
+      psd = PSD.new('spec/files/pixel.psd')
+      psd.parse!
+
+      # File should parse
+      expect(psd).to be_parsed
+
+      # Slices should still be not nil
+      expect(psd.resources[:slices]).to_not be_nil
+
+      # But slices version should be equal to 6
+      expect(psd.resources[:slices].data.version).to eq 6
+
+      # Bounds should not be nil
+      psd.resources[:slices].data.to_a.each do |slice|
+        expect(slice).to_not be_nil
+        expect(slice[:bounds]).to_not be_nil
+      end
+    end
+  end
+
+  describe "Handle file without slices properly" do
+    it "should successfully parse a PSD file which does not have slices" do
+      psd = PSD.new('spec/files/simplest.psd')
+      psd.parse!
+
+      expect(psd).to be_parsed
+
+      expect(psd.resources[:slices].data.to_a.size).to be 1
+      expect(psd.resources[:slices].data.to_a[0][:id]).to be 0
+    end
+  end
+end

data/vendor/psd.rb/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require './lib/psd'
+
+class PSD
+  attr_reader :file
+end
+
+RSpec.configure do |config|
+  unless ENV['CIRCLECI']
+    config.filter_run :focus => true
+  end
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+end

data/vendor/psd.rb/spec/text_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe 'Text' do
+  it "should parse text layer" do
+    psd = PSD.new('spec/files/text.psd')
+    psd.parse!
+
+    text = psd.tree.children.first.text
+    text.should be_an_instance_of(Hash)
+    expect(text[:value]).to eq('Test')
+  end
+
+  it "can be exported as CSS" do
+    psd = PSD.new('spec/files/text.psd')
+    psd.parse!
+
+    type = psd.tree.children.first.type
+    css = type.to_css
+    expect(css).to be_an_instance_of(String)
+    expect(css).to include 'MyriadPro-Regular'
+    expect(css).to include '37.0pt'
+    expect(css).to include 'rgba(24, 24, 24, 255)'
+    css.split(/\n/).each do |c|
+      expect(c[-1]).to eq(";")
+    end
+  end
+end

data/vendor/psd_native/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in psd_native.gemspec
+gemspec

data/vendor/psd_native/Guardfile

@@ -0,0 +1,6 @@
+guard 'rspec', cli: '--color' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { "spec" }
+  watch(%r{^ext/(.+)$})     { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/vendor/psd_native/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ryan LeFevre
+
+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/vendor/psd_native/README.md

@@ -0,0 +1,48 @@
+# PSDNative
+
+[![Travis CI](https://travis-ci.org/layervault/psd_native.png)](https://travis-ci.org/layervault/psd_native)
+
+A gem that includes multiple mixins that speed up [PSD.rb](https://github.com/layervault/psd.rb) by delegating certain parts of the library to native C code. This library allows for PSD.rb to function as a pure Ruby library, while allowing for optional native code speed improvements. It overwrites specific methods within PSD.rb transparently, so you can use PSD.rb like normal.
+
+Currently, PSDNative replaces these sections of PSD.rb with native code:
+
+* RGB processing
+* CMYK processing
+* Greyscale processing
+* RLE decoding
+* Some color conversions
+* Color composition
+* Clipping masks
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'psd_native'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install psd_native
+
+## Usage
+
+Simply require `psd_native` instead of `psd`, and you're good to go.
+
+``` ruby
+require 'psd_native'
+
+psd = PSD.new("path/to/file.psd")
+psd.parse!
+```
+
+## 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