psd 0.4.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db9f14cd10de0296d8511ad83cf909f20519d3ca
-  data.tar.gz: 0246042fd4037c9466a0cde4f215ebe411d529e4
+  metadata.gz: 8e806c5a8d10b43d7bddb5bf2e0e9ca3843a579f
+  data.tar.gz: 5560fc10135e67e5d396a367c5ae737cf0f84c51
 SHA512:
-  metadata.gz: e05a52e512a93122255bda14fb3cbb329b75dd5e7be620eed20e7bccf9f109e1ea969b5430383e7910313a22afa6e4e2842631182fd11d4925d998f2a52bfa44
-  data.tar.gz: 82ebbb3fcee334bc73f039dde683c635724cf674f6b392f9523dd30cbf43d17ec54d04f4c2eeb360b93c7f09f781812abb5db30363efc35e6cf2bdcb2245e879
+  metadata.gz: bcac2c4003765bc89eaba409c48b860bcc6d49ec377953332dcfccbb58baecc9b7531d285a95cfeaff14c1f8102b5b8bfab341ae915b4270f67760d271abf186
+  data.tar.gz: c8656fe0d3ccb52301f09e40856a0f90d1ad7ebeba4ba2793a0cc3edef958fd57daa9e16a69034abf1ae416420126bd1e9e456da5ba69b7edc28d0483755c3cb

data/README.md

@@ -184,7 +184,6 @@ PSD.debug = true
 
 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

data/lib/psd/color.rb

@@ -4,122 +4,120 @@ class PSD
   # value of some kind. This means that we have to do all the conversion ourselves
   # for each color space.
   class Color
-    instance_eval do
       # This is a relic of libpsd that will likely go away in a future version. It
       # stored the entire color value in a 32-bit address space for speed.
-      def color_space_to_argb(color_space, color_component)
-        color = case color_space
-        when 0
-          rgb_to_color *color_component
-        when 1
-          hsb_to_color color_component[0], 
-            color_component[1] / 100.0, color_component[2] / 100.0
-        when 2
-          cmyk_to_color color_component[0] / 100.0,
-            color_component[1] / 100.0, color_component[2] / 100.0,
-            color_component[3] / 100.0
-        when 7
-          lab_to_color *color_component
-        else
-          0x00FFFFFF
-        end
-
-        color_to_argb(color)
+    def self.color_space_to_argb(color_space, color_component)
+      color = case color_space
+      when 0
+        rgb_to_color *color_component
+      when 1
+        hsb_to_color color_component[0], 
+          color_component[1] / 100.0, color_component[2] / 100.0
+      when 2
+        cmyk_to_color color_component[0] / 100.0,
+          color_component[1] / 100.0, color_component[2] / 100.0,
+          color_component[3] / 100.0
+      when 7
+        lab_to_color *color_component
+      else
+        0x00FFFFFF
       end
 
-      def color_to_argb(color)
-        [
-          (color) >> 24,
-          ((color) & 0x00FF0000) >> 16,
-          ((color) & 0x0000FF00) >> 8,
-          (color) & 0x000000FF
-        ]
-      end
+      color_to_argb(color)
+    end
 
-      def rgb_to_color(*args)
-        argb_to_color(255, *args)
-      end
+    def self.color_to_argb(color)
+      [
+        (color) >> 24,
+        ((color) & 0x00FF0000) >> 16,
+        ((color) & 0x0000FF00) >> 8,
+        (color) & 0x000000FF
+      ]
+    end
 
-      def argb_to_color(a, r, g, b)
-        (a << 24) | (r << 16) | (g << 8) | b
-      end
+    def self.rgb_to_color(*args)
+      argb_to_color(255, *args)
+    end
 
-      def hsb_to_color(*args)
-        ahsb_to_color(255, *args)
-      end
+    def self.argb_to_color(a, r, g, b)
+      (a << 24) | (r << 16) | (g << 8) | b
+    end
 
-      def ahsb_to_color(alpha, hue, saturation, brightness)
-        if saturation == 0.0
-          b = g = r = (255 * brightness).to_i
+    def self.hsb_to_color(*args)
+      ahsb_to_color(255, *args)
+    end
+
+    def self.ahsb_to_color(alpha, hue, saturation, brightness)
+      if saturation == 0.0
+        b = g = r = (255 * brightness).to_i
+      else
+        if brightness <= 0.5
+          m2 = brightness * (1 + saturation)
         else
-          if brightness <= 0.5
-            m2 = brightness * (1 + saturation)
-          else
-            m2 = brightness + saturation - brightness * saturation
-          end
-
-          m1 = 2 * brightness - m2
-          r = hue_to_color(hue + 120, m1, m2)
-          g = hue_to_color(hue, m1, m2)
-          b = hue_to_color(hue - 120, m1, m2)
+          m2 = brightness + saturation - brightness * saturation
         end
 
-        argb_to_color alpha, r, g, b
+        m1 = 2 * brightness - m2
+        r = hue_to_color(hue + 120, m1, m2)
+        g = hue_to_color(hue, m1, m2)
+        b = hue_to_color(hue - 120, m1, m2)
       end
 
-      def hue_to_color(hue, m1, m2)
-        hue = (hue % 360).to_i
-        if hue < 60
-          v = m1 + (m2 - m1) * hue / 60
-        elsif hue < 180
-          v = m2
-        elsif hue < 240
-          v = m1 + (m2 - m1) * (240 - hue) / 60
-        else
-          v = m1
-        end
+      argb_to_color alpha, r, g, b
+    end
 
-        (v * 255).to_i
+    def self.hue_to_color(hue, m1, m2)
+      hue = (hue % 360).to_i
+      if hue < 60
+        v = m1 + (m2 - m1) * hue / 60
+      elsif hue < 180
+        v = m2
+      elsif hue < 240
+        v = m1 + (m2 - m1) * (240 - hue) / 60
+      else
+        v = m1
       end
 
-      def cmyk_to_color(c, m, y, k)
-        r = 1 - (c * (1 - k) + k) * 255
-        g = 1 - (m * (1 - k) + k) * 255
-        b = 1 - (y * (1 - k) + k) * 255
+      (v * 255).to_i
+    end
 
-        r = [0, r, 255].sort[1]
-        g = [0, g, 255].sort[1]
-        b = [0, b, 255].sort[1]
+    def self.cmyk_to_color(c, m, y, k)
+      r = 1 - (c * (1 - k) + k) * 255
+      g = 1 - (m * (1 - k) + k) * 255
+      b = 1 - (y * (1 - k) + k) * 255
 
-        rgb_to_color r, g, b
-      end
+      r = [0, r, 255].sort[1]
+      g = [0, g, 255].sort[1]
+      b = [0, b, 255].sort[1]
 
-      def lab_to_color(*args)
-        alab_to_color(255, *args)
-      end
+      rgb_to_color r, g, b
+    end
 
-      def alab_to_color(alpha, l, a, b)
-        xyz = lab_to_xyz(l, a, b)
-        axyz_to_color alpha, xyz[:x], xyz[:y], xyz[:z]
-      end
+    def self.lab_to_color(*args)
+      alab_to_color(255, *args)
+    end
 
-      def lab_to_xyz(l, a, b)
-        y = (l + 16) / 116
-        x = y + (a / 500)
-        z = y - (b / 200)
+    def self.alab_to_color(alpha, l, a, b)
+      xyz = lab_to_xyz(l, a, b)
+      axyz_to_color alpha, xyz[:x], xyz[:y], xyz[:z]
+    end
 
-        x, y, z = [x, y, z].map do |n|
-          n**3 > 0.008856 ? n**3 : (n - 16 / 116) / 7.787
-        end
-      end
+    def self.lab_to_xyz(l, a, b)
+      y = (l + 16) / 116
+      x = y + (a / 500)
+      z = y - (b / 200)
 
-      def cmyk_to_rgb(c, m, y, k)
-        Hash[{
-          r: (65535 - (c * (255 - k) + (k << 8))) >> 8,
-          g: (65535 - (m * (255 - k) + (k << 8))) >> 8,
-          b: (65535 - (y * (255 - k) + (k << 8))) >> 8
-        }.map { |k, v| [k, Util.clamp(v, 0, 255)] }]
+      x, y, z = [x, y, z].map do |n|
+        n**3 > 0.008856 ? n**3 : (n - 16 / 116) / 7.787
       end
     end
+
+    def self.cmyk_to_rgb(c, m, y, k)
+      Hash[{
+        r: (65535 - (c * (255 - k) + (k << 8))) >> 8,
+        g: (65535 - (m * (255 - k) + (k << 8))) >> 8,
+        b: (65535 - (y * (255 - k) + (k << 8))) >> 8
+      }.map { |k, v| [k, Util.clamp(v, 0, 255)] }]
+    end
   end
 end

data/lib/psd/image_modes/greyscale.rb

@@ -2,22 +2,6 @@ class PSD::Image::Mode
   module Greyscale
     private
 
-    def combine_greyscale8_channel
-      if channels == 2
-        # We have an alpha channel
-        @num_pixels.times do |i|
-          alpha = @channel_data[i]
-          grey = @channel_data[@channel_length + i]
-
-          @pixel_data.push grey, grey, grey, alpha
-        end
-      else
-        @num_pixels.times do |i|
-          @pixel_data.push *([@channel_data[i]] * 3), 255
-        end
-      end
-    end
-
     def combine_greyscale_channel
       if channels == 2
         (0...@num_pixels).step(pixel_step) do |i|

data/lib/psd/layer_info/typetool.rb

@@ -58,7 +58,7 @@ class PSD
         name: fonts.first,
         sizes: sizes,
         colors: colors,
-        css: parser.to_css
+        css: to_css
       }
     end
 
@@ -80,7 +80,8 @@ class PSD
     #
     # => [[255, 0, 0, 255], [0, 0, 255, 255]]
     def colors
-      return [] if engine_data.nil? || !styles.has_key?('FillColor')
+      # 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
@@ -115,6 +116,26 @@ class PSD
       @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,

data/lib/psd/layer_mask.rb

@@ -115,7 +115,7 @@ class PSD
       @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
+      @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]

data/lib/psd/nodes/ancestry.rb

@@ -27,7 +27,7 @@ class PSD
       end
 
       # Inverse of has_children?
-      def is_childless?
+      def childless?
         !has_children?
       end
 
@@ -44,7 +44,7 @@ class PSD
       end
 
       # Is this node the only descendant of its parent?
-      def is_only_child?
+      def only_child?
         siblings.length == 1
       end
 

data/lib/psd/version.rb

@@ -1,3 +1,3 @@
 class PSD
-  VERSION = "0.4.2"
+  VERSION = "1.0.0"
 end

data/psd.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency "bindata"
   gem.add_dependency "oily_png"
-  gem.add_dependency 'psd-enginedata'
+  gem.add_dependency 'psd-enginedata', '~> 1.0'
 
   gem.test_files = Dir.glob("spec/**/*")
   gem.add_development_dependency 'rspec'

data/spec/hierarchy_spec.rb

@@ -9,8 +9,8 @@ describe "Hierarchy" do
     @psd.parse!
     
     tree = @psd.tree.to_hash
-    tree.should include :children
-    tree[:children].length.should == 3
+    expect(tree).to include :children
+    expect(tree[:children].length).to eq(3)
   end
 
   describe "Ancestry" do
@@ -20,66 +20,66 @@ describe "Hierarchy" do
     end
 
     it "should provide tree traversal methods" do
-      @tree.respond_to?(:root).should be_true
-      @tree.respond_to?(:siblings).should be_true
-      @tree.respond_to?(:descendants).should be_true
-      @tree.respond_to?(:subtree).should be_true
+      expect(@tree).to respond_to(:root)
+      expect(@tree).to respond_to(:siblings)
+      expect(@tree).to respond_to(:descendants)
+      expect(@tree).to respond_to(:subtree)
     end
 
     it "should properly identify the root node" do
-      @tree.root?.should be_true
-      @tree.root.should == @tree
-      @tree.children.last.root.should == @tree
+      expect(@tree.root?).to be_true
+      expect(@tree.root).to be @tree
+      expect(@tree.children.last.root).to be @tree
     end
 
     it "should retrieve all descendants of a node" do
-      @tree.descendants.size.should == 12
-      @tree.descendant_layers.size.should == 9
-      @tree.descendant_groups.size.should == 3
-      @tree.descendants.first.should_not == @tree
+      expect(@tree.descendants.size).to eq(12)
+      expect(@tree.descendant_layers.size).to eq(9)
+      expect(@tree.descendant_groups.size).to eq(3)
+      expect(@tree.descendants.first).not_to be @tree
     end
 
     it "should retreive the entire subtree of a node" do
-      @tree.subtree.size.should == 13
-      @tree.subtree_layers.size.should == 9
-      @tree.subtree_groups.size.should == 3
-      @tree.subtree.first.should == @tree
+      expect(@tree.subtree.size).to eq(13)
+      expect(@tree.subtree_layers.size).to eq(9)
+      expect(@tree.subtree_groups.size).to eq(3)
+      expect(@tree.subtree.first).to be @tree
     end
 
     it "should properly identify the existence of children" do
-      @tree.has_children?.should be_true
-      @tree.is_childless?.should be_false
-      @tree.descendant_layers.first.has_children?.should be_false
-      @tree.descendant_layers.first.is_childless?.should be_true
+      expect(@tree).to have_children
+      expect(@tree).to_not be_childless
+      expect(@tree.descendant_layers.first).to_not have_children
+      expect(@tree.descendant_layers.first).to be_childless
     end
 
     it "should retrieve all siblings of a node" do
-      @tree.children.first.siblings.should == @tree.children
-      @tree.children.first.siblings.should include @tree.children.first
-      @tree.children.first.has_siblings?.should be_true
-      @tree.children.first.is_only_child?.should be_false
+      expect(@tree.children.first.siblings).to be @tree.children
+      expect(@tree.children.first.siblings).to include @tree.children.first
+      expect(@tree.children.first).to have_siblings
+      expect(@tree.children.first).to_not be_only_child
     end
 
     it "should properly calculate node depth" do
-      @tree.depth.should == 0
-      @tree.descendant_layers.last.depth.should == 2
-      @tree.children.first.depth.should == 1
+      expect(@tree.depth).to eq(0)
+      expect(@tree.descendant_layers.last.depth).to eq(2)
+      expect(@tree.children.first.depth).to eq(1)
     end
 
     describe "Searching" do
       it "should find a node given a path" do
-        @tree.children_at_path('Version A/Matte').is_a?(Array).should be_true
-        @tree.children_at_path('Version A/Matte').size.should == 1
-        @tree.children_at_path('Version A/Matte').first.is_a?(PSD::Node::Layer).should be_true
+        expect(@tree.children_at_path('Version A/Matte')).to be_an_instance_of(Array)
+        expect(@tree.children_at_path('Version A/Matte').size).to eq(1)
+        expect(@tree.children_at_path('Version A/Matte').first).to be_an_instance_of(PSD::Node::Layer)
       end
 
       it "should ignore leading slashes" do
-        @tree.children_at_path('/Version A/Matte').size.should == 1
+        expect(@tree.children_at_path('/Version A/Matte').size).to eq(1)
       end
 
       it "should return an empty array when a node is not found" do
-        @tree.children_at_path('LOLWUTOMGBBQSAUCE').is_a?(Array).should be_true
-        @tree.children_at_path('LOLWUTOMGBBQSAUCE').size.should == 0
+        expect(@tree.children_at_path('NOPE')).to be_an_instance_of(Array)
+        expect(@tree.children_at_path('NOPE').size).to eq(0)
       end
     end
   end

data/spec/identity_spec.rb

@@ -9,7 +9,7 @@ describe "Identity exports" do
     tmpfile = Tempfile.new("simplest_export.psd")
     psd.export tmpfile.path
 
-    Digest::MD5.hexdigest(tmpfile.read).should == Digest::MD5.hexdigest(File.read(filepath))
+    expect(Digest::MD5.hexdigest(tmpfile.read)).to eq(Digest::MD5.hexdigest(File.read(filepath)))
   end
 
   it "should export a file with a layer" do
@@ -19,7 +19,7 @@ describe "Identity exports" do
     tmpfile = Tempfile.new("one_layer_export.psd")
     psd.export tmpfile.path
 
-    Digest::MD5.hexdigest(tmpfile.read).should == Digest::MD5.hexdigest(File.read(filepath))
+    expect(Digest::MD5.hexdigest(tmpfile.read)).to eq(Digest::MD5.hexdigest(File.read(filepath)))
   end
 
   it "should export a PSD with vector paths" do
@@ -29,6 +29,6 @@ describe "Identity exports" do
     tmpfile = Tempfile.new("path_export.psd")
     psd.export tmpfile.path
 
-    Digest::MD5.hexdigest(tmpfile.read).should == Digest::MD5.hexdigest(File.read(filepath))
+    expect(Digest::MD5.hexdigest(tmpfile.read)).to eq(Digest::MD5.hexdigest(File.read(filepath)))
   end
 end

data/spec/parsing_spec.rb

@@ -7,7 +7,7 @@ describe 'Parsing' do
 
   it "should parse without error" do
     @psd.parse!
-    @psd.parsed?.should be_true
+    expect(@psd).to be_parsed
   end
 
   describe 'Header' do
@@ -16,25 +16,25 @@ describe 'Parsing' do
     end
 
     it "should contain data" do
-      @psd.header.should_not be_nil
+      expect(@psd.header).not_to be_nil
     end
 
     it "should be the proper version" do
-      @psd.header.version.should == 1
+      expect(@psd.header.version).to eq(1)
     end
 
     it "should have the proper number of channels" do
-      @psd.header.channels.should == 3
+      expect(@psd.header.channels).to eq(3)
     end
 
     it "should parse the proper document dimensions" do
-      @psd.header.width.should == 900
-      @psd.header.height.should == 600
+      expect(@psd.header.width).to eq(900)
+      expect(@psd.header.height).to eq(600)
     end
 
     it "should correctly parse the color mode" do
-      @psd.header.mode.should == 3
-      @psd.header.mode_name.should == 'RGBColor'
+      expect(@psd.header.mode).to eq(3)
+      expect(@psd.header.mode_name).to eq('RGBColor')
     end
   end
 
@@ -44,18 +44,18 @@ describe 'Parsing' do
     end
 
     it "should contain data" do
-      @psd.resources.should_not be_nil
-      @psd.resources.data.is_a?(Hash).should be_true
-      @psd.resources.data.size.should >= 1
+      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| r.type.should == '8BIM' }
+      @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|
-        r.id.should_not be_nil
+        expect(r.id).to_not be_nil
       end
     end
   end
@@ -66,18 +66,19 @@ describe 'Parsing' do
     end
 
     it "should contain data" do
-      @psd.layer_mask.should_not be_nil
-      @psd.layer_mask.is_a?(PSD::LayerMask).should be_true
+      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
-      @psd.layer_mask.layers.size.should > 0
+      expect(@psd.layer_mask.layers.size).to be > 0
     end
 
     it "should contain the global layer mask data" do
-      pending "Not implemented yet"
-
-      @psd.layer_mask.global_mask.should_not be_nil
+      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
 
@@ -87,48 +88,48 @@ describe 'Parsing' do
     end
 
     it "should contain each layer" do
-      @psd.layer_mask.layers.size.should == 15
-      @psd.layers.should == @psd.layer_mask.layers
-      @psd.layers.each { |l| l.is_a?(PSD::Layer).should be_true }
+      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
-      @psd.layers.first.name.should == 'Version C'
+      expect(@psd.layers.first.name).to eq('Version C')
     end
 
     it "should properly identify folders" do
-      @psd.layers.first.folder?.should be_true
-      @psd.layers.select { |l| l.name == 'Matte' }.first.folder?.should be_false
+      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
-      @psd.layers.first.visible?.should be_false
-      @psd
-        .layers
-        .select { |l| l.name == 'Version A' }.first
-        .visible?
-        .should be_true
+      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
-      layer.width.should == 142
-      layer.height.should == 179
+      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
-      layer.left.should == 379
-      layer.top.should == 210
+      expect(layer.left).to eq(379)
+      expect(layer.top).to eq(210)
     end
 
     it "should have a blend mode" do
-      layer = @psd.layers.select { |l| l.name == 'Version A' }.last
-      layer.blend_mode.should_not be_nil
-      layer.blend_mode.mode.should == 'normal'
-      layer.blend_mode.opacity.should == 255
-      layer.blend_mode.opacity_percentage.should == 100
-      layer.blend_mode.visible.should be_true
+      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
   end
 end

data/spec/psd_spec.rb

@@ -5,8 +5,8 @@ describe 'PSD' do
 
 	it 'should open a file without a block' do
     psd = PSD.open(filename)
-    psd.parsed?.should == true
-    psd.should be_instance_of PSD
+    expect(psd).to be_parsed
+    expect(psd).to be_an_instance_of(PSD)
 	end
 
   it 'should refuse to open a bad filename' do
@@ -15,11 +15,13 @@ describe 'PSD' do
 
   it 'should open a file and feed it to a block' do
     PSD.open(filename) do |psd|
-      psd.parsed?.should == true
-      psd.should be_instance_of 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

data/spec/text_spec.rb

@@ -7,6 +7,21 @@ describe 'Text' do
 
     text = psd.tree.children.first.text
     text.should be_an_instance_of(Hash)
-    text[:value].should == 'Test'
+    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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: psd
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Ryan LeFevre
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-21 00:00:00.000000000 Z
+date: 2013-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bindata
@@ -43,16 +43,16 @@ dependencies:
   name: psd-enginedata
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement