frameit 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 994d66e0107d1487eae24acaeb5bd997849a7055
-  data.tar.gz: c8e9b01111ee2435795097129d1d243141bb4cfb
+  metadata.gz: 39874df0b50f3d2b85da9a8e15fd1a63639cc090
+  data.tar.gz: e0ef4228c227cadd7557cab83bc3a17c09361e9a
 SHA512:
-  metadata.gz: 8feb6bb7edb9952d64a35dea949c63401d73ddd72307db8e0c128621a606c517df4e63f776973ac9be3fa1d263a5cebb3ee359def50e5a52af012ae72b91d466
-  data.tar.gz: 26ab1ba67b648f4e466f50e236ce7dd36c113a702465ece6e2f4b63a09ef3d29ae859d5afce6c676dfb8b6c265113aac8eaadd1508899f93e27131d0417a0228
+  metadata.gz: ffb3757b70c4a004f0a69462526ac341e676bc26c011d23164733e9217b30a4c80714419babd61bce104b8d47985a76f0e50924cda6fbc9b7f8d4e8ddc7dd362
+  data.tar.gz: ad69ccef5a466dbe23ba6a1533372c351a191961df49084ade21683ecff7024b0ff9bcc08dafa4ec198222366a5d0f8b7da11c83ab9c5b74b06edadfc2696998

data/LICENSE

@@ -19,3 +19,6 @@ 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.
+
+All screenshots located inside the 'assets' folder of this directory are excluded
+from this license. 

data/README.md

@@ -27,11 +27,10 @@ frameit
 [![Twitter: @KauseFx](https://img.shields.io/badge/contact-@KrauseFx-blue.svg?style=flat)](https://twitter.com/KrauseFx)
 [![License](http://img.shields.io/badge/license-MIT-green.svg?style=flat)](https://github.com/KrauseFx/frameit/blob/master/LICENSE)
 [![Gem](https://img.shields.io/gem/v/frameit.svg?style=flat)](http://rubygems.org/gems/frameit)
+[![Build Status](https://img.shields.io/travis/fastlane/frameit/master.svg?style=flat)](https://travis-ci.org/fastlane/frameit)
 
 ###### Quickly put your screenshots into the right device frames
 
-This tool is not supposed to be used for App Store screenshots. Instead it should be used to prepare screenshots for websites, emails and prints.
-
 Get in contact with the developer on Twitter: [@KrauseFx](https://twitter.com/KrauseFx)
 
 
@@ -60,10 +59,7 @@ Put a gorgeous device frame around your iOS screenshots just by running one simp
 
 Here is a nice gif, that shows ```frameit``` in action:
 
-![assets/FrameitGit.gif](assets/FrameitGit.gif)
-
-Here is how the result can look like
-![assets/Overview.png](assets/Overview.png)
+![assets/FrameitGit.gif](assets/FrameitGit.gif?raw=1)
 
 # Installation
 
@@ -103,6 +99,8 @@ To run the setup process again to add new frames use:
 
     frameit setup
 
+When using `frameit` without titles on top, the screenshots will have the full resolution, which means they can't be uploaded to the App Store directly. They are supposed to be used for websites, print media and emails. Check out the section below to use the screenshots for the App Store.
+
 # Tips
 
 ## [`fastlane`](https://fastlane.tools) Toolchain
@@ -118,8 +116,12 @@ To run the setup process again to add new frames use:
 
 ##### [Like this tool? Be the first to know about updates and new fastlane tools](https://tinyletter.com/krausefx)
 
-## Generate screenshots
-Check out [```Snapshot```](https://github.com/KrauseFx/snapshot) to automatically generate screenshots using ```UI Automation```.
+## Generate localized screenshots
+Check out [`snapshot`](https://github.com/KrauseFx/snapshot) to automatically generate screenshots using ```UI Automation```.
+
+## White background of frames
+
+Some stock images provided by Apple still have a white background instead of a transparent one. You'll have to edit the Photoshop file to remove the white background, delete the generated `.png` file and run `frameit` again.
 
 ## Use a clean status bar
 You can use [SimulatorStatusMagic](https://github.com/shinydevelopment/SimulatorStatusMagic) to clean up the status bar.

data/bin/frameit

@@ -29,7 +29,7 @@ class FrameItApplication
       c.description = "Adds a black frame around all screenshots."
 
       c.action do |args, options|
-        Frameit::Editor.new.run('.', Frameit::Editor::Color::BLACK)
+        Frameit::Runner.new.run('.', Frameit::Color::BLACK)
       end
     end
 
@@ -38,7 +38,7 @@ class FrameItApplication
       c.description = "Adds a silver frame around all screenshots."
       
       c.action do |args, options|
-        Frameit::Editor.new.run('.', Frameit::Editor::Color::SILVER)
+        Frameit::Runner.new.run('.', Frameit::Color::SILVER)
       end
     end
 
@@ -60,6 +60,7 @@ end
 
 begin
   FastlaneCore::UpdateChecker.start_looking_for_update('frameit')
+  Frameit::DependencyChecker.check_dependencies
   FrameItApplication.new.run
 ensure
   FastlaneCore::UpdateChecker.show_update_status('frameit', Frameit::VERSION)

data/lib/frameit.rb

@@ -1,13 +1,27 @@
 require 'mini_magick'
 require 'frameit/version'
 require 'frameit/frame_converter'
+require 'frameit/device_types'
+require 'frameit/runner'
+require 'frameit/screenshot'
+require 'frameit/config_parser'
+require 'frameit/offsets'
 require 'frameit/editor'
+require 'frameit/template_finder'
+require 'frameit/strings_parser'
+require 'frameit/mac_editor'
 require 'frameit/dependency_checker'
 
 require 'fastlane_core'
 
 module Frameit
   Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
-
-  Frameit::DependencyChecker.check_dependencies
 end
+
+
+class ::Hash
+  def fastlane_deep_merge(second)
+    merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+    self.merge(second, &merger)
+  end
+end

data/lib/frameit/config_parser.rb

@@ -0,0 +1,83 @@
+module Frameit
+  class ConfigParser
+    def load(path)
+      return nil unless File.exists?(path) # we are okay with no config at all
+      Helper.log.info "Parsing config file '#{path}'".yellow if $verbose
+      @path = path
+      self.parse(File.read(path))
+    end
+
+
+
+    # @param data (String) the JSON data to be parsed
+    def parse(data)
+      begin
+        @data = JSON.parse(data)
+      rescue => ex
+        Helper.log.fatal ex
+        raise "Invalid JSON file at path '#{@path}'. Make sure it's a valid JSON file".red
+      end
+
+      self
+    end
+
+    # Fetches the finished configuration for a given path. This will try to look for a specific value
+    # and fallback to a default value if nothing was found
+    def fetch_value(path)
+      specific = @data['data'].find { |a| path.include?a['filter'] }
+      
+      default = @data['default']
+
+      values = default.fastlane_deep_merge(specific || {})
+
+      change_paths_to_absolutes!(values)
+      validate_values(values)
+
+      values
+    end
+
+    # Use absolute paths instead of relative
+    def change_paths_to_absolutes!(values)
+      values.each do |key, value|
+        if value.kind_of?Hash
+          change_paths_to_absolutes!(value) # recursive call
+        else
+          if ['font', 'background'].include?key
+            # Change the paths to relative ones
+            # `replace`: to change the content of the string, so it's actually stored
+
+            if @path # where is the config file. We don't have a config file in tests
+              containing_folder = File.expand_path('..', @path) 
+              value.replace File.join(containing_folder, value)
+            end
+          end
+        end
+      end
+    end
+
+    # Make sure the paths/colors are valid
+    def validate_values(values)
+      values.each do |key, value|
+        if value.kind_of?Hash
+          validate_values(value) # recursive call
+        else
+          if key == 'font'
+            raise "Could not find font at path '#{File.expand_path(value)}'" unless File.exists?value
+          end
+
+          if key == 'background'
+            raise "Could not find background image at path '#{File.expand_path(value)}'" unless File.exists?value
+          end
+
+          if key == 'color'
+            raise "Invalid color '#{value}'. Must be valid Hex #123123" unless value.include?"#"
+          end
+
+          if key == 'padding'
+            raise "padding must be type integer" unless value.kind_of?Integer
+          end
+        end
+      end
+    end
+  end
+end

data/lib/frameit/dependency_checker.rb

@@ -1,6 +1,8 @@
 module Frameit
   class DependencyChecker
     def self.check_dependencies
+      return if Helper.is_test?
+      
       self.check_image_magick
     end
 

data/lib/frameit/device_types.rb

@@ -0,0 +1,11 @@
+module Frameit
+  module Color
+    BLACK = "SpaceGray"
+    SILVER = "Slvr"
+  end
+
+  module Orientation
+    PORTRAIT = "Vert"
+    LANDSCAPE = "Horz"
+  end
+end

data/lib/frameit/editor.rb

@@ -1,172 +1,239 @@
-require 'deliver'
-require 'fastimage'
-
 module Frameit
   class Editor
-    module Color
-      BLACK = "SpaceGray"
-      SILVER = "Slvr"
-    end
+    attr_accessor :screenshot # reference to the screenshot object to fetch the path, title, etc.
+    attr_accessor :frame # the frame of the device
+    attr_accessor :image # the current image used for editing
+    attr_accessor :top_space_above_device
 
-    module Orientation
-      PORTRAIT = "Vert"
-      LANDSCAPE = "Horz"
-    end
+    def frame!(screenshot)
+      self.screenshot = screenshot
+      prepare_image
 
+      if load_frame # e.g. Mac doesn't need a frame
+        self.frame = MiniMagick::Image.open(load_frame)
+      end
 
-    def initialize
-      converter = FrameConverter.new
-      unless converter.frames_exist?
-        # First run
-        converter.run
+      if should_add_title?
+        @image = complex_framing
       else
-        # Just make sure, the PSD files are converted to PNG
-        converter.convert_frames
+        # easy mode from 1.0 - no title or background
+        width = offset['width']
+        image.resize width # resize the image to fit the frame
+        put_into_frame # put it in the frame
       end
+
+      store_result # write to file system
     end
 
-    def run(path, color = Color::BLACK)
-      @color = color
-
-      screenshots = Dir.glob("#{path}/**/*.{png,PNG}")
-
-      if screenshots.count > 0
-        screenshots.each do |screenshot|
-          next if screenshot.include?"_framed.png"
-          next if screenshot.include?".itmsp/" # a package file, we don't want to modify that
-          
-          begin
-            template_path = get_template(screenshot)
-            if template_path
-              template = MiniMagick::Image.open(template_path)
-              image = MiniMagick::Image.open(screenshot)
-
-              offset_information = image_offset(screenshot)
-              raise "Could not find offset_information for '#{screenshot}'" unless (offset_information and offset_information[:width])
-              width = offset_information[:width]
-              image.resize width
-
-              result = template.composite(image, "png") do |c|
-                c.compose "Over"
-                c.geometry offset_information[:offset]
-              end
-
-              output_path = screenshot.gsub('.png', '_framed.png').gsub('.PNG', '_framed.png')
-              result.format "png"
-              result.write output_path
-              Helper.log.info "Added frame: '#{File.expand_path(output_path)}'".green
-            end
-          rescue => ex
-            Helper.log.error ex
-          end
+    def load_frame
+      TemplateFinder.get_template(screenshot)
+    end
+
+    def prepare_image
+      @image = MiniMagick::Image.open(screenshot.path)
+    end
+
+
+    private
+      def store_result
+        output_path = screenshot.path.gsub('.png', '_framed.png').gsub('.PNG', '_framed.png')
+        image.format "png"
+        image.write output_path
+        Helper.log.info "Added frame: '#{File.expand_path(output_path)}'".green
+      end
+
+      # puts the screenshot into the frame
+      def put_into_frame
+        @image = frame.composite(image, "png") do |c|
+          c.compose "Over"
+          c.geometry offset['offset']
         end
-      else 
-        Helper.log.error "Could not find screenshots"
       end
-    end
 
-    # This will detect the screen size and choose the correct template
-    def get_template(path)
-      parts = [
-        device_name(screen_size(path)),
-        orientation_name(path),
-        @color
-      ]
-
-      templates_path = [ENV['HOME'], FrameConverter::FRAME_PATH].join('/')
-      templates = Dir["#{templates_path}/**/#{parts.join('_')}*.png"]
-
-      if templates.count == 0
-        if screen_size(path) == Deliver::AppScreenshot::ScreenSize::IOS_35
-          Helper.log.warn "Unfortunately 3.5\" device frames were discontinued. Skipping screen '#{path}'".yellow
-        else
-          Helper.log.error "Could not find a valid template for screenshot '#{path}'".red
-          Helper.log.error "You can download new templates from '#{FrameConverter::DOWNLOAD_URL}'"
-          Helper.log.error "and store them in '#{templates_path}'"
-          Helper.log.error "Missing file: '#{parts.join('_')}.psd'".red
+      def offset
+        return @offset_information if @offset_information
+
+        @offset_information = fetch_config['offset'] || Offsets.image_offset(screenshot)
+
+        if @offset_information and (@offset_information['offset'] or @offset_information['offset'])
+          return @offset_information
         end
-        return nil
-      else
-        # Helper.log.debug "Found template '#{templates.first}' for screenshot '#{path}'"
-        return templates.first.gsub(" ", "\ ")
+        raise "Could not find offset_information for '#{screenshot}'"
       end
-    end
 
-    private
-      def screen_size(path)
-        Deliver::AppScreenshot.calculate_screen_size(path)
-      end
-
-      def device_name(screen_size)
-        size = Deliver::AppScreenshot::ScreenSize
-        case screen_size
-          when size::IOS_55
-            return 'iPhone_6_Plus'
-          when size::IOS_47
-            return 'iPhone_6'
-          when size::IOS_40
-            return 'iPhone_5s'
-          when size::IOS_IPAD
-            return 'iPad_mini'
+      #########################################################################################
+      # Everything below is related to title, background, etc. and is not used in the easy mode
+      #########################################################################################
+
+      # this is used to correct the 1:1 offset information
+      # the offset information is stored to work for the template images
+      # since we resize the template images to have higher quality screenshots
+      # we need to modify the offset information by a certain factor
+      def modify_offset(multiplicator)
+        # Format: "+133+50"
+        hash = offset['offset']
+        x = hash.split("+")[1].to_f * multiplicator
+        y = hash.split("+")[2].to_f * multiplicator
+        new_offset = "+#{x.round}+#{y.round}"
+        @offset_information['offset'] = new_offset
+      end
+
+      # Do we add a background and title as well?
+      def should_add_title?
+        return (fetch_config['background'] and (fetch_config['title'] or fetch_config['keyword']))
+      end
+
+      # more complex mode: background, frame and title
+      def complex_framing
+        background = generate_background
+        
+        if self.frame # we have no frame on le mac
+          resize_frame!
+          @image = put_into_frame
+
+          # Decrease the size of the framed screenshot to fit into the defined padding + background
+          frame_width = background.width - fetch_config['padding'] * 2
+          image.resize "#{frame_width}x"
+        end
+
+        @@image = put_device_into_background(background)
+
+        if fetch_config['title']
+          @image = add_title
+        end
+
+        image
+      end
+
+      # Returns a correctly sized background image
+      def generate_background
+        background = MiniMagick::Image.open(fetch_config['background'])
+
+        if background.height != screenshot.size[1]
+          background.resize "#{screenshot.size[0]}x#{screenshot.size[1]}!" # `!` says it should ignore the ratio
+        end
+        background
+      end
+
+      def put_device_into_background(background)
+        left_space = (background.width / 2.0 - image.width / 2.0).round
+        bottom_space = -(image.height / 10).round # to be just a bit below the image bottom
+        bottom_space -= 40 if screenshot.is_portrait? # even more for portrait mode
+
+        self.top_space_above_device = background.height - image.height - bottom_space
+
+        @image = background.composite(image, "png") do |c|
+          c.compose "Over"
+          c.geometry "+#{left_space}+#{top_space_above_device}"
         end
+
+        return image
       end
 
-      def orientation_name(path)
-        size = FastImage.size(path)
-        return Orientation::PORTRAIT if size[0] < size[1]
-        return Orientation::LANDSCAPE
-      end
-
-      def image_offset(path)
-        size = Deliver::AppScreenshot::ScreenSize
-        case orientation_name(path)
-          when Orientation::PORTRAIT
-            case screen_size(path)
-              when size::IOS_55
-                return { 
-                  offset: '+42+147',
-                  width: 539
-                }
-              when size::IOS_47
-                return {
-                  offset: '+41+154',
-                  width: 530
-                }
-              when size::IOS_40
-                return {
-                  offset: "+54+197",
-                  width: 543
-                }
-              when size::IOS_IPAD
-                return {
-                  offset: '+50+134',
-                  width: 792
-                }
-            end
-          when Orientation::LANDSCAPE
-            case screen_size(path)
-              when size::IOS_55
-                return { 
-                  offset: "+146+41",
-                  width: 960
-                }
-              when size::IOS_47
-                return {
-                  offset: "+153+41",
-                  width: 946
-                }
-              when size::IOS_40
-                return {
-                  offset: "+201+48",
-                  width: 970
-                }
-              when size::IOS_IPAD
-                return {
-                  offset: '+133+50',
-                  width: 1058
-                }
-            end
+      # Resize the frame as it's too low quality by default
+      def resize_frame!
+        multiplicator = (screenshot.size[0].to_f / offset['width'].to_f) # by how much do we have to change this?
+        new_frame_width = multiplicator * frame.width # the new width for the frame
+        frame.resize "#{new_frame_width.round}x" # resize it to the calculated witdth
+        modify_offset(multiplicator) # modify the offset to properly insert the screenshot into the frame later
+      end
+
+      # Add the title above the device
+      def add_title
+        title_images = build_title_images(image.width)
+        keyword = title_images[:keyword]
+        title = title_images[:title]
+
+        sum_width = (keyword.width rescue 0) + title.width + keyword_padding
+        top_space = (top_space_above_device / 2.0 - actual_font_size / 2.0).round # centered
+        
+        left_space = (image.width / 2.0 - sum_width / 2.0).round
+        if keyword
+          @image = image.composite(keyword, "png") do |c|
+            c.compose "Over"
+            c.geometry "+#{left_space}+#{top_space}"
+          end
         end
+
+        left_space += (keyword.width rescue 0) + keyword_padding
+        @image = image.composite(title, "png") do |c|
+          c.compose "Over"
+          c.geometry "+#{left_space}+#{top_space}"
+        end
+        image
+      end
+
+      def actual_font_size
+        (screenshot.size[0] / 20.0).round # depends on the width of the screenshot
+      end
+
+      def keyword_padding
+        (actual_font_size / 2.0).round
       end
+
+      # This will build 2 individual images with the title, which will then be added to the real image
+      def build_title_images(max_width)
+        words = [:keyword, :title].keep_if{ |a| fetch_text(a) } # optional keyword/title
+        results = {}
+        words.each do |key|
+          # Create empty background
+          empty_path = File.join(Helper.gem_path('frameit'), "lib/assets/empty.png")
+          title_image = MiniMagick::Image.open(empty_path)
+          image_height = actual_font_size * 2 # gets trimmed afterwards anyway, and on the iPad the `y` would get cut
+          title_image.combine_options do |i|
+            i.resize "#{max_width}x#{image_height}!" # `!` says it should ignore the ratio
+          end
+
+          # Add the actual title
+          font = fetch_config[key.to_s]['font']
+          title_image.combine_options do |i|
+            i.font font if font
+            i.gravity "Center"
+            i.pointsize actual_font_size
+            i.draw "text 0,0 '#{fetch_text(key)}'"
+            i.fill fetch_config[key.to_s]['color']
+          end
+          title_image.trim # remove white space
+
+          results[key] = title_image
+        end
+        results
+      end
+
+      # Loads the config (colors, background, texts, etc.)
+      # Don't use this method to access the actual text and use `fetch_texts` instead
+      def fetch_config
+        return @config if @config
+
+        config_path = File.join(File.expand_path("..", screenshot.path), "Framefile.json")
+        config_path = File.join(File.expand_path("../..", screenshot.path), "Framefile.json") unless File.exists?config_path
+        file = ConfigParser.new.load(config_path)
+        return {} unless file # no config file at all
+        @config = file.fetch_value(screenshot.path)
+      end
+
+      # Fetches the title + keyword for this particular screenshot
+      def fetch_text(type)
+        raise "Valid parameters :keyword, :title" unless [:keyword, :title].include?type
+
+        # Try to get it from a keyword.strings or title.strings file
+        strings_path = File.join(File.expand_path("..", screenshot.path), "#{type.to_s}.strings")
+        if File.exists?strings_path
+          parsed = StringsParser.parse(strings_path)
+          result = parsed.find { |k, v| screenshot.path.include?k }
+          return result.last if result
+        end
+
+        # No string files, fallback to Framefile config
+        result = fetch_config[type.to_s]['text']      
+
+        if !result and type == :title
+          # title is mandatory
+          raise "Could not get title for screenshot #{screenshot.path}. Please provide one in your Framefile.json".red
+        end
+
+        return result
+      end
+
   end
-end
+end

data/lib/frameit/frame_converter.rb

@@ -45,7 +45,7 @@ module Frameit
     end
 
     def frames_exist?
-      Dir["#{templates_path}/**/*.psd"].count > 0
+      (Dir["#{templates_path}/**/*.psd"].count + Dir["../**/*sRGB.png"].count) > 0
     end
 
     def templates_path

data/lib/frameit/mac_editor.rb

@@ -0,0 +1,33 @@
+module Frameit
+  # Responsible for framing Mac Screenshots
+  class MacEditor < Editor
+
+    def prepare_image
+      image = super
+      image.resize("#{offset['width']}x") if offset['width']
+    end
+
+    def put_device_into_background(background)
+      self.top_space_above_device = offset['titleHeight'] # needed for centering the title
+
+      @image = background.composite(image, "png") do |c|
+        c.compose "Over"
+        c.geometry offset['offset']
+      end
+
+      return image
+    end
+
+    def load_frame
+      nil # Macs don't need frames - backgrounds only
+    end
+
+    def should_add_title?
+      true # Mac screenshots always need a background
+    end
+
+    def generate_background
+      MiniMagick::Image.open(fetch_config['background']) # no resizing on the Mac
+    end
+  end
+end

data/lib/frameit/offsets.rb

@@ -0,0 +1,62 @@
+module Frameit
+  class Offsets
+    # Returns the image offset needed for a certain device type for a given orientation
+    # uses deliver to detect the screen size
+    def self.image_offset(screenshot)
+      size = Deliver::AppScreenshot::ScreenSize
+      case screenshot.orientation_name
+        when Orientation::PORTRAIT
+          case screenshot.screen_size
+            when size::IOS_55
+              return { 
+                'offset' => '+42+147',
+                'width' => 539
+              }
+            when size::IOS_47
+              return {
+                'offset' => '+41+154',
+                'width' => 530
+              }
+            when size::IOS_40
+              return {
+                'offset' => "+54+197",
+                'width' => 543
+              }
+            when size::IOS_IPAD
+              return {
+                'offset' => '+50+134',
+                'width' => 792
+              }
+          end
+        when Orientation::LANDSCAPE
+          case screenshot.screen_size
+            when size::IOS_55
+              return { 
+                'offset' => "+146+41",
+                'width' => 960
+              }
+            when size::IOS_47
+              return {
+                'offset' => "+153+41",
+                'width' => 946
+              }
+            when size::IOS_40
+              return {
+                'offset' => "+201+48",
+                'width' => 970
+              }
+            when size::IOS_35
+              return {
+                'offset' => "+258+52",
+                'width' => 966
+              }
+            when size::IOS_IPAD
+              return {
+                'offset' => '+133+50',
+                'width' => 1058
+              }
+          end
+      end
+    end
+  end
+end

data/lib/frameit/runner.rb

@@ -0,0 +1,38 @@
+require 'deliver'
+require 'fastimage'
+
+module Frameit
+  class Runner
+    def initialize
+      converter = FrameConverter.new
+      unless converter.frames_exist?
+        # First run
+        converter.run
+      else
+        # Just make sure, the PSD files are converted to PNG
+        converter.convert_frames
+      end
+    end
+
+    def run(path, color = Color::BLACK)
+      screenshots = Dir.glob("#{path}/**/*.{png,PNG}")
+
+      if screenshots.count > 0
+        screenshots.each do |full_path|
+          next if full_path.include?"_framed.png"
+          next if full_path.include?".itmsp/" # a package file, we don't want to modify that
+          next if full_path.include?"device_frames/" # these are the device frames the user is using
+          
+          begin
+            screenshot = Screenshot.new(full_path, color)
+            screenshot.frame!
+          rescue => ex
+            Helper.log.error ex
+          end
+        end
+      else 
+        Helper.log.error "Could not find screenshots"
+      end
+    end
+  end
+end

data/lib/frameit/screenshot.rb

@@ -0,0 +1,66 @@
+module Frameit
+  # Represents one screenshot
+  class Screenshot
+    attr_accessor :path # path to the screenshot
+    attr_accessor :size # size in px array of 2 elements: height and width
+    attr_accessor :screen_size # deliver screen size type, is unique per device type, used in device_name
+    attr_accessor :color # the color to use for the frame
+
+    # path: Path to screenshot
+    # color: Color to use for the frame
+    def initialize(path, color)
+      raise "Couldn't find file at path '#{path}'".red unless File.exists?path
+      @color = color
+      @path = path
+      @size = FastImage.size(path)
+
+      @screen_size = ENV["FRAMEIT_FORCE_DEVICE_TYPE"] || Deliver::AppScreenshot.calculate_screen_size(path) 
+    end
+
+    # Device name for a given screen size. Used to use the correct template
+    def device_name
+      sizes = Deliver::AppScreenshot::ScreenSize
+      case @screen_size
+        when sizes::IOS_55
+          return 'iPhone_6_Plus'
+        when sizes::IOS_47
+          return 'iPhone_6'
+        when sizes::IOS_40
+          return 'iPhone_5s'
+        when sizes::IOS_35
+          return 'iPhone_4'
+        when sizes::IOS_IPAD
+          return 'iPad_mini'
+        when sizes::MAC
+          return 'Mac'
+      end
+    end
+
+    def is_mac?
+      return device_name == 'Mac'
+    end
+
+    # The name of the orientation of a screenshot. Used to find the correct template
+    def orientation_name
+      return Orientation::PORTRAIT if size[0] < size[1]
+      return Orientation::LANDSCAPE
+    end
+
+    def is_portrait?
+      return (orientation_name == Orientation::PORTRAIT)
+    end
+
+    def to_s
+      self.path
+    end
+
+    # Add the device frame, this will also call the method that adds the background + title
+    def frame!
+      if self.is_mac?
+        MacEditor.new.frame!(self)
+      else
+        Editor.new.frame!(self)
+      end
+    end
+  end
+end

data/lib/frameit/strings_parser.rb

@@ -0,0 +1,31 @@
+module Frameit
+  # This class will parse the .string files
+  class StringsParser
+    def self.parse(path)
+      raise "Couldn't find strings file at path '#{path}'".red unless File.exists?path
+      raise "Must be .strings file, only got '#{path}'".red unless path.end_with?".strings"
+
+      result = {}
+
+      # A .strings file is UTF-16 encoded. We only want to deal with UTF-8
+      content = `iconv -f UTF-16 -t UTF-8 '#{path}'`
+
+      content.split("\n").each do |line|
+        begin
+          # We don't care about comments and empty lines
+          if line.start_with?'"'
+            key = line.match(/"(.*)" \= /)[1]
+            value = line.match(/ \= "(.*)"/)[1]
+
+            result[key] = value
+          end
+        rescue => ex
+          Helper.log.error ex          
+          Helper.log.error line
+        end
+      end
+      
+      result
+    end
+  end
+end

data/lib/frameit/template_finder.rb

@@ -0,0 +1,37 @@
+module Frameit
+  # Responsible for finding the correct device
+  class TemplateFinder
+
+    # This will detect the screen size and choose the correct template
+    def self.get_template(screenshot)
+      return nil if screenshot.is_mac?
+      parts = [
+        screenshot.device_name,
+        screenshot.orientation_name,
+        screenshot.color
+      ]
+      parts << "sRGB" if screenshot.device_name == 'iPad_mini'
+
+
+      templates_path = [ENV['HOME'], FrameConverter::FRAME_PATH].join('/')
+      templates = Dir["../**/#{parts.join('_')}*.{png,jpg}"] # local directory
+      templates = templates + Dir["#{templates_path}/**/#{parts.join('_')}*.{png,jpg}"] # ~/.frameit folder
+      
+
+      if templates.count == 0
+        if screenshot.screen_size == Deliver::AppScreenshot::ScreenSize::IOS_35
+          Helper.log.warn "Unfortunately 3.5\" device frames were discontinued. Skipping screen '#{screenshot.path}'".yellow
+          Helper.log.debug "Looked for: '#{parts.join('_')}.png'".red
+        else
+          Helper.log.error "Could not find a valid template for screenshot '#{screenshot.path}'".red
+          Helper.log.error "You can download new templates from '#{FrameConverter::DOWNLOAD_URL}'"
+          Helper.log.error "and store them in '#{templates_path}'"
+          Helper.log.error "Missing file: '#{parts.join('_')}.png'".red
+        end
+        return nil
+      else
+        return templates.first.gsub(" ", "\ ")
+      end
+    end
+  end
+end

data/lib/frameit/version.rb

@@ -1,3 +1,3 @@
 module Frameit
-  VERSION = "1.0.1"
+  VERSION = "2.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: frameit
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Felix Krause
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-22 00:00:00.000000000 Z
+date: 2015-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fastlane_core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.7.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.7.2
 - !ruby/object:Gem::Dependency
   name: fastimage
   requirement: !ruby/object:Gem::Requirement
@@ -137,7 +137,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.8.7.4
 - !ruby/object:Gem::Dependency
-  name: codeclimate-test-reporter
+  name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -161,10 +161,19 @@ files:
 - LICENSE
 - README.md
 - bin/frameit
+- lib/assets/empty.png
 - lib/frameit.rb
+- lib/frameit/config_parser.rb
 - lib/frameit/dependency_checker.rb
+- lib/frameit/device_types.rb
 - lib/frameit/editor.rb
 - lib/frameit/frame_converter.rb
+- lib/frameit/mac_editor.rb
+- lib/frameit/offsets.rb
+- lib/frameit/runner.rb
+- lib/frameit/screenshot.rb
+- lib/frameit/strings_parser.rb
+- lib/frameit/template_finder.rb
 - lib/frameit/version.rb
 homepage: https://fastlane.tools
 licenses: