psd-enginedata 0.2.3

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,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  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,112 @@
+# PSD EngineData
+
+Adobe thought it would be cool to create their own markup language for text data embedded within a Photoshop document. I've taken the liberty of calling it EngineData since that is the name used in the descriptor embedded within PSD files. This is a general purpose parser for that data.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'psd-enginedata'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install psd-enginedata
+
+## Usage
+
+``` ruby
+# From File
+parser = PSD::EngineData.load('path/to/file')
+
+# From string
+parser = PSD::EngineData.new(text)
+
+# Parse it
+parser.parse!
+
+# Use it
+puts parser.result.Editor.Text
+```
+
+## File Spec
+
+The EngineData format uses certain characters to denote various data types. All newlines are denoted with a UNIX newline (\n) and it is not indentation-aware (although it seems to be stored with pretty indentation in the PSD file).
+
+```
+<<
+  /EngineDict
+  <<
+    /Editor
+    <<
+      /Text (˛ˇMake a change and save.)
+    >>
+  >>
+  /Font
+  <<
+    /Name (˛ˇHelveticaNeue-Light)
+    /FillColor
+    <<
+      /Type 1
+      /Values [ 1.0 0.0 0.0 0.0 ]
+    >>
+    /StyleSheetSet [
+    <<
+      /Name (˛ˇNormal RGB)
+    >>
+    ]
+  >>
+>>
+```
+
+There are 6 data types available to use:
+
+* Dictionary/Hash
+* Array (single or multi-line)
+* Float
+* Integer
+* String
+* Boolean
+
+Altogether we have a non-turing complete markup language with some interesting quirks that was written in 1998 with the release of Photoshop 5.0 since it included the ability to edit text areas after they were created (before that, they were rasterized immediately).
+
+### Property Names
+
+Property names are started with a `/` followed by an alphanumeric word. The property value either comes after a space or a new line.
+
+### Dictionaries/Hashes
+
+Dictionaries are denoted by a property name (unless at the root), followed by a new line and the `<<` instruction. The end of a dictionary is denoted by the `>>` instruction.
+
+A dictionary can contain any type of data including more dictionaries for nesting purposes. All values within a dictionary must have a property followed by a value of some kind.
+
+### Arrays
+
+Arrays come in two flavors: single-line or multi-line. Both are denoted by square brackets `[ ]`.
+
+Single-line arrays can only hold number values (doubles or integers). While it wouldn't be out of the question for it to hold string or boolean values, this does not seem to appear in any tested Photoshop documents so we're going to assume it's not a part of the specification. Values in single-line arrays are **space delimited**. There seems to be a space between the opening and closing square brackets and the data, but we assume it's optional.
+
+Multi-line arrays can contain any type of data. Values in multi-line arrays are newline-denoted. The opening bracket for multi-line arrays must occur on the same line as the property to which it belongs.
+
+### Floats/Integers
+
+Basically, numbers can be expressed with or without a decimal point. Floats are of the form `1.76`, but the non-fractional digits to the left of the decimal point are optional. Integers are just numbers with no commas or decimal points.
+
+### Strings
+
+Strings are delimited by parentheses with a cedilla-breve (thanks [Rob](http://github.com/robgrant) for the terminology) at the start of the string. Since operations are UNIX newline (\n) delimited within the document, new lines in strings are denoted by carriage returns (\r).
+
+### Booleans
+
+Booleans are simply denoted by `true` or `false`. Cool.
+
+## 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/lib/psd/enginedata.rb

@@ -0,0 +1,93 @@
+# -*- encoding : utf-8 -*-
+require 'hashie'
+
+dir_root = File.dirname(File.absolute_path(__FILE__)) + '/enginedata'
+[
+  '/instructions/*',
+  '/exporters/*',
+  '/**/*'
+].each do |path|
+  Dir.glob(dir_root + path) { |file| require file if File.file?(file) }
+end
+
+class PSD
+  # General purpose parser for the text data markup present within PSD documents.
+  class EngineData
+    attr_reader   :text
+    attr_accessor :property_stack, :node_stack, :property, :node
+    alias :result :node
+
+    include DocumentHelpers
+    include Export
+
+    # All of the instructions as defined by the EngineData spec.
+    INSTRUCTIONS = [
+      Instruction::HashStart,
+      Instruction::HashEnd,
+      Instruction::SingleLineArray,
+      Instruction::MultiLineArrayStart,
+      Instruction::MultiLineArrayEnd,
+      Instruction::Property,
+      Instruction::PropertyWithData,
+      Instruction::String,
+      Instruction::NumberWithDecimal,
+      Instruction::Number,
+      Instruction::Boolean,
+      Instruction::Noop
+    ]
+
+    # Read a file containing EngineData markup and initialize a new instance.
+    def self.load(file)
+      self.new File.read(file)
+    end
+
+    # Create a new Text instance and initialize our parsing stacks.
+    def initialize(text)
+      @text = Text.new(text)
+
+      @property_stack = []
+      @node_stack = []
+
+      @property = :root
+      @node = nil
+
+      @parsed = false
+    end
+
+    # Parses the full document.
+    def parse!
+      return if parsed?
+
+      while true
+        line = @text.current
+        @parsed = true and return if line.nil?
+
+        parse_tokens(line)
+        @text.next!
+      end
+    end
+
+    # Has the document been parsed yet?
+    def parsed?
+      @parsed
+    end
+
+    # Go through each instruction until a token match is found, then parse the
+    # matches.
+    def parse_tokens(text)
+      INSTRUCTIONS.each do |inst|
+        match = inst.match(text)
+        return inst.new(self, text).execute! if match
+      end
+
+      # This is a hack for the Japanese character rules that the format embeds
+      match = Instruction::String.match(text + @text.next)
+      if match
+        text += @text.next!
+        return Instruction::String.new(self, text).execute!
+      end
+
+      raise TokenNotFound.new("Text = #{text.dump}, Line = #{@text.line + 1}")
+    end
+  end
+end

data/lib/psd/enginedata/document_helpers.rb

@@ -0,0 +1,46 @@
+# -*- encoding : utf-8 -*-
+class PSD
+  class EngineData
+    # A collection of helper methods that are used to manipulate the internal
+    # data structure while parsing.
+    module DocumentHelpers
+      # Pushes a property and node onto the parsing stack.
+      def stack_push(property = nil, node = nil)
+        node = @node if node.nil?
+        property = @property if property.nil?
+
+        @node_stack.push node
+        @property_stack.push property
+      end
+
+      # Pops a property and node from the parsing stack
+      def stack_pop
+        return @property_stack.pop, @node_stack.pop
+      end
+
+      # Sets the current active node
+      def set_node(node)
+        @node = node
+      end
+
+      # Creates a new node
+      def reset_node
+        @node = Node.new
+      end
+
+      # Sets the current active property
+      def set_property(property = nil)
+        @property = property
+      end
+
+      # Updates a node with a given property and child node.
+      def update_node(property, node)
+        if node.is_a?(PSD::EngineData::Node)
+          node[property] = @node
+        elsif node.is_a?(Array)
+          node.push @node
+        end
+      end
+    end
+  end
+end

data/lib/psd/enginedata/errors.rb

@@ -0,0 +1,6 @@
+# -*- encoding : utf-8 -*-
+class PSD
+  class EngineData #:nodoc:
+    class TokenNotFound < StandardError; end
+  end
+end

data/lib/psd/enginedata/export.rb

@@ -0,0 +1,8 @@
+# -*- encoding : utf-8 -*-
+class PSD
+  class EngineData
+    module Export #:nodoc:
+      include CSS
+    end
+  end
+end

data/lib/psd/enginedata/exporters/css.rb

@@ -0,0 +1,65 @@
+# -*- encoding : utf-8 -*-
+class PSD
+  class EngineData
+    module Export
+      # Exports the document to a CSS string.
+      module CSS
+        # 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
+          parse! unless parsed?
+          
+          definition = {}
+          definition.merge! font_family
+          definition.merge! font_size
+          definition.merge! font_color
+
+          css = []
+          definition.each do |k, v|
+            css << "#{k}: #{v};"
+          end
+
+          css.join("\n")
+        end
+
+        private
+
+        def font_family
+          font = result.ResourceDict.FontSet.map { |f| %{"#{f.Name}"} }.join(', ')
+
+          {
+            'font-family' => font
+          }
+        end
+
+        def font_size
+          {
+            'font-size' => "#{styles.FontSize}pt"
+          }
+        end
+
+        def font_color
+          return {} unless styles.key?('FillColor')
+
+          color = styles.FillColor.Values.map { |c| (c * 255).round }
+          if color.length == 3
+            alpha = 255
+          else
+            alpha = color.shift
+          end
+
+          {
+            'color' => "rgba(#{color.join(', ')}, #{alpha})"
+          }
+        end
+
+        def styles
+          result.EngineDict.StyleRun.RunArray[0].StyleSheet.StyleSheetData
+        end
+      end
+    end
+  end
+end

data/lib/psd/enginedata/instruction.rb

@@ -0,0 +1,39 @@
+# -*- encoding : utf-8 -*-
+class PSD
+  class EngineData
+    # A single instruction as defined by the EngineData spec.
+    class Instruction
+      # The regex for the token, defaulted to nil. Override this.
+      def self.token; end
+
+      # Checks to see if the given text is a match for this token.
+      def self.match(text)
+        token.match(text)
+      end
+
+      # Stores a reference to the EngineData document and the current
+      # String being parsed.
+      def initialize(document, text)
+        @document = document
+        @text = text
+      end
+
+      # Returns the regex match to the current string.
+      def match
+        self.class.match @text
+      end
+
+      # Once matched, we execute the instruction and apply the changes
+      # to the parsed data.
+      def execute!; end
+
+      def method_missing(method, *args, &block)
+        if @document.respond_to?(method)
+          return @document.send(method, *args)
+        end
+
+        super
+      end
+    end
+  end
+end