motion-screenshots 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1e45e4d791f33c71d3d293f9378b29f3507bb16a
+  data.tar.gz: ac7d5bbf01f869d5c460c523bb2d0cbddd5b8b83
+SHA512:
+  metadata.gz: 14ed0214424a55bd7cc9b3a5dce879a00052ff650d878cef4fa704380d4d0adc3380c6104ed2be1eab236cb60d05954eeae9ee0475751e55caca9d2dab9ae1d3
+  data.tar.gz: 9bdde2151c34ee0b6a9b6944479d5e37020ffd271c4c227deb32f443fb8b94e18f006af64d9c2edaeb2b1ee91329c3019c238f498517937a1feba2c1da067287

data/README.md

@@ -0,0 +1,95 @@
+# motion-screenshots
+
+Automate your App Store screenshots with `rake screenshots`. Powered by [KSScreenshotManager](https://github.com/ksuther/KSScreenshotManager).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'motion-screenshots'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install motion-screenshots
+
+## Usage
+
+### Configuration
+
+By default, screenshots will be placed in a `./screenshots/#{timestamp}` directory in your project. You can configure this a few different ways:
+
+- `ENV['SCREENSHOTS_DIR']` - use this environment variable
+- `app.screenshots_output_path=` - set this value in your Rakefile
+- `app.manage_screenshots do |output_path|` - add this block in your Rakefile
+
+### Code
+
+Create one or more subclasses of `Motion::Screenshots::Base` and add them to `./app/screenshots`. This class uses a DSL you can use to setup what happens before and after various screenshots are taken.
+
+```ruby
+class AppScreenshots < Motion::Screenshots::Base
+
+  # Use `.screenshot` to take a synchronous shot
+  screenshot "menu" do
+    before do
+      # scroll down for a nice action shot
+      App.delegate.table_view_controller.scrollToRowAtIndexPath(
+        NSIndexPath.indexPathForRow(2, inSection: 1),
+        animated: false,
+        scrollPosition: UITableViewScrollPositionMiddle
+      )
+    end
+  end
+
+  # Use `.async_screenshot` to take a screenshot
+  # at some point in the future (i.e. a timer, network calls, etc)
+  # Invoke `#ready!` to take the shot
+  async_screenshot "profile" do
+    before do
+      App.delegate.table_view_controller.selectRowAtIndexPath(
+        NSIndexPath.indexPathForRow(0, inSection: 1),
+        animated: false,
+        scrollPosition: UITableViewScrollPositionNone
+      )
+
+      # give the network some time...
+      Dispatch::Queue.main.after(3) {
+        ready!
+      }
+    end
+
+    # clean-up
+    after do
+      App.window.rootViewController.popViewControllerAnimated(false)
+    end
+  end
+end
+```
+
+Then, elsewhere in your code, simply let motion-screenshots know when to start the process:
+
+```ruby
+class AppDelegate
+
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+    # do other stuff...
+
+    AppScreenshots.start!
+  end
+end
+```
+
+Screenshots are executed in the order listed in your class - doing any cleanup or pre-screenshot preparation is left to you.
+
+### Running
+
+Simple run `rake screenshots` and you're off! The task will uninstall and reinstall your CocoaPods, as to not include any of the private APIs bundled with `KSScreenshotManager`.
+
+## Contact
+
+[Clay Allsopp](http://clayallsopp.com/)
+[@clayallsopp](https://twitter.com/clayallsopp)

data/lib/motion/motion-screenshots.rb

@@ -0,0 +1,108 @@
+if !Kernel.const_defined?(:KSScreenshotManager)
+  class KSScreenshotManager
+    def init
+      @started = true
+    end
+  end
+end
+
+module Motion
+  module Screenshots
+    class Base < KSScreenshotManager
+      SCREENSHOTS_BASE_FOLDER = "motion_screenshots"
+      class << self
+        # Adds a namespace folder for this screenshot class
+        def group_by(&block)
+          shared.group_by_block = block
+        end
+
+        def async_screenshot(title, &block)
+          shared.async_screenshot(title, &block)
+        end
+
+        def screenshot(title, &block)
+          shared.screenshot(title, &block)
+        end
+
+        def start!
+          shared.start!
+        end
+
+        private
+          def shared
+            @shared ||= alloc.init
+          end
+      end
+
+      attr_accessor :group_by_block, :screenshot_groups
+
+      def init
+        super
+        @group_by_block = nil
+        @screenshot_groups = []
+        self
+      end
+
+      def group_by(&block)
+        @group_by_block = block
+      end
+
+      def async_screenshot(title, &block)
+        @screenshot_groups << ScreenshotGroup.new(title, true, self, &block)
+      end
+
+      def screenshot(title, &block)
+        @screenshot_groups << ScreenshotGroup.new(title, false, self, &block)
+      end
+
+      def setupScreenshotActions
+        @screenshot_groups.each do |sg|
+          addScreenshotAction sg.to_KSScreenshotAction
+        end
+      end
+
+      def start!
+        return if @started
+
+        @started = true
+
+        documents_path = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, true)[0].retain
+        screenshot_path = File.join(documents_path, SCREENSHOTS_BASE_FOLDER)
+        screenshot_path = File.join(screenshot_path, group_by_block.call) if @group_by_block
+        self.screenshotsURL = NSURL.fileURLWithPath(screenshot_path)
+
+        takeScreenshots
+      end
+    end
+
+    class ScreenshotGroup
+      def initialize(title, is_async, manager, &eval_block)
+        @title = title
+        @is_async = is_async
+        @manager = manager
+        @before_actions = nil
+        @after_actions = nil
+        instance_eval(&eval_block) if eval_block
+      end
+
+      def before(&actions)
+        @before_actions = actions
+      end
+
+      def after(&actions)
+        @after_actions = actions
+      end
+
+      def ready!
+        @manager.actionIsReady
+      end
+
+      def to_KSScreenshotAction
+        KSScreenshotAction.actionWithName(@title, asynchronous: @is_async,
+          actionBlock:-> { @before_actions.call if @before_actions },
+          cleanupBlock: -> { @after_actions.call if @after_actions }
+        )
+      end
+    end
+  end
+end

data/lib/motion-screenshots.rb

@@ -0,0 +1,64 @@
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+require 'motion-cocoapods'
+require 'fileutils'
+require 'shellwords'
+
+lib_dir_path = File.dirname(File.expand_path(__FILE__))
+Motion::Project::App.setup do |app|
+  gem_files = Dir.glob(File.join(lib_dir_path, "motion/**/*.rb"))
+  app.files.unshift(gem_files).flatten!
+end
+
+module Motion; module Project; class Config
+  attr_accessor :screenshot_callback
+
+  variable :screenshots_output_path
+
+  def manage_screenshots(&block)
+    @screenshot_callback = block
+  end
+end; end; end
+
+namespace 'screenshots' do
+  task :start do
+    screenshots_output_path = ENV['SCREENSHOTS_DIR']
+    screenshots_output_path ||= App.config.screenshots_output_path
+    screenshots_output_path ||= File.join(`pwd`.strip, "screenshots", Time.now.to_i.to_s)
+    FileUtils.mkdir_p screenshots_output_path
+
+    app_config = Motion::Project::App.config_without_setup
+    app_config.pods do
+      pod 'KSScreenshotManager'
+    end
+
+    at_exit {
+      # Copy files
+      target = ENV['target'] || app_config.sdk_version
+      sim_apps = File.expand_path("~/Library/Application Support/iPhone Simulator/*/Applications")
+      app_dir = nil
+      app = app_config.app_bundle('iPhoneSimulator')
+      app_dir = File.dirname(Dir.glob("#{sim_apps}/**/#{File.basename(app)}").sort_by { |f|
+        File.mtime(f)
+      }.reverse.first)
+      motion_screenshots = File.join(app_dir, "Documents", "motion_screenshots")
+      screenshot_files = Dir[File.join(motion_screenshots, "**", "*")]
+      FileUtils.cp_r(screenshot_files, screenshots_output_path)
+      if app_config.screenshot_callback
+        app_config.screenshot_callback.call(screenshots_output_path)
+      else
+        `open #{screenshots_output_path.shellescape}`
+      end
+      puts "Re-installing pods..."
+      `bundle exec rake pod:install`
+    }
+
+    Rake::Task["pod:install"].invoke
+    Rake::Task["default"].invoke
+  end
+end
+
+desc "Take screenshots in your app"
+task :screenshots => "screenshots:start"

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: motion-screenshots
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Clay Allsopp
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: motion-cocoapods
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Take screenshots with RubyMotion
+email:
+- clay@usepropeller.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/motion/motion-screenshots.rb
+- lib/motion-screenshots.rb
+homepage: https://github.com/usepropeller/motion-screenshots
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Take screenshots with RubyMotion
+test_files: []