nitron 0.2

data/.gitignore

@@ -0,0 +1,2 @@
+.repl_history
+build

data/README.md

@@ -0,0 +1,83 @@
+Nitron
+===================
+
+Introduction
+----------
+Nitron is an opinionated, loosely-coupled set of RubyMotion components designed to accelerate iOS
+development, especially with simpler iOS apps. It provides meaningful
+abstractions atop the strong foundation present in the iOS SDK.
+
+This first release focuses on making Storyboard-based workflows enjoyable.
+
+Installation
+----------
+Add the following line to your `Gemfile`:
+
+`gem "nitron"`
+
+If you haven't already, update your Rakefile to use Bundler. Insert the
+following immediately before `Motion::Project::App.setup`:
+
+```ruby
+require 'rubygems'
+require 'bundler'
+
+Bundler.require
+```
+
+Example
+------
+A modal view controller responsible for creating new `Tasks`:
+
+```ruby
+class TaskCreateViewController < Nitron::ViewController
+  # The on class method is part of Nitron's Action DSL.
+  # It wires the provided block to be an event handler for the specified outlet using the iOS target/action pattern.
+  on :cancel do
+    close
+  end
+
+  # Nitron emulates 'native' outlet support, allowing you to easily define outlets through Xcode.
+  # The titleField and datePicker methods are created upon initial load by using metadata contained in the Storyboard.
+  on :save do
+    Task.create(title: titleField.text, due: datePicker.date)
+
+    close
+  end
+end
+```
+
+Features
+----------
+
+* **Data Binding** - declaratively bind your model data to controls, either
+  via code or Interface Builder
+* **Outlet Support** - expose controls to your controllers via Interface Builder
+* **Action Support** - Ruby DSL to attach event handlers to outlets
+* **CoreData Models** - beginnings of a CoreData model abstraction uses
+  XCode's data modeling tools with an ActiveRecord-like syntax
+
+If you notice, many of these features aim at slimming down your
+controllers. This is no accident: many iOS controllers have far too many
+responsibilities. Glue code is a perfect target for metaprogramming, so
+we're focusing on making beautiful controllers presently.
+
+We're also careful to make these features modular, so you can mix them
+into your existing controllers as needed.
+
+Tutorial
+----------
+TBD
+
+Examples
+----------
+https://github.com/mattgreen/nitron-examples
+
+Caveats
+---------
+
+* Data binding doesn't use KVO presently. This is already in the works.
+* Action support is limited to selecting a button or a table cell.
+  Future releases will expand the DSL to support additional events.
+* CoreData needs support for relationships and migrations.
+

data/lib/nitron.rb

@@ -0,0 +1,20 @@
+require 'nitron/version'
+
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+Motion::Project::App.setup do |app|
+  Dir.glob(File.join(File.dirname(__FILE__), "nitron/**/*.rb")).each do |file|
+    app.files.unshift(file)
+  end
+
+  app.files.unshift(File.join(File.dirname(__FILE__), 'nitron/view_controller.rb'))
+  app.files.unshift(File.join(File.dirname(__FILE__), 'nitron/ui/data_binding_support.rb'))
+  app.files.unshift(File.join(File.dirname(__FILE__), 'nitron/ui/outlet_support.rb'))
+  app.files.unshift(File.join(File.dirname(__FILE__), 'nitron/ui/action_support.rb'))
+
+  unless app.frameworks.include?("CoreData")
+    app.frameworks << "CoreData"
+  end
+end

data/lib/nitron/data/extensions/app_delegate+core_data.rb

@@ -0,0 +1,43 @@
+class AppDelegate
+  def managedObjectContext
+    @managedObjectContext ||= begin
+      applicationName = NSBundle.mainBundle.infoDictionary.objectForKey("CFBundleName")
+
+      documentsDirectory = NSFileManager.defaultManager.URLsForDirectory(NSDocumentDirectory, inDomains:NSUserDomainMask).lastObject;
+      storeURL = documentsDirectory.URLByAppendingPathComponent("#{applicationName}.sqlite")
+
+      error_ptr = Pointer.new(:object)
+      unless persistentStoreCoordinator.addPersistentStoreWithType(NSSQLiteStoreType, configuration:nil, URL:storeURL, options:nil, error:error_ptr)
+        raise "Can't add persistent SQLite store: #{error_ptr[0].description}"
+      end
+
+      context = NSManagedObjectContext.alloc.init
+      context.persistentStoreCoordinator = persistentStoreCoordinator
+
+      context
+    end
+  end
+
+  def managedObjectModel
+    @managedObjectModel ||= begin
+      model = NSManagedObjectModel.mergedModelFromBundles([NSBundle.mainBundle]).mutableCopy
+
+      model.entities.each do |entity|
+        begin
+          Kernel.const_get(entity.name)
+          entity.setManagedObjectClassName(entity.name)
+
+        rescue NameError
+          entity.setManagedObjectClassName("Model")
+        end
+      end
+
+      model
+    end
+  end
+
+  def persistentStoreCoordinator
+    @coordinator ||= NSPersistentStoreCoordinator.alloc.initWithManagedObjectModel(managedObjectModel)
+  end
+end
+

data/lib/nitron/data/model.rb

@@ -0,0 +1,100 @@
+module Nitron
+  class Model < NSManagedObject
+    class << self
+      def all
+        Data::Relation.alloc.initWithClass(self)
+      end
+
+      def create(attributes={})
+        model = new(attributes)
+        model.save
+
+        model
+      end
+
+      def destroy(object)
+        if context = object.managedObjectContext
+          context.deleteObject(object)
+
+          error = Pointer.new(:object)
+          context.save(error)
+        end
+      end
+
+      def entityDescription
+        @_metadata ||= UIApplication.sharedApplication.delegate.managedObjectModel.entitiesByName[name]
+      end
+
+      def find(object_id)
+        unless entity = find_by_id(object_id)
+          raise "No record found!"
+        end
+
+        entity
+      end
+
+      def first
+        relation.first
+      end
+
+      def method_missing(method, *args, &block)
+        if method.start_with?("find_by_")
+          attribute = method.gsub("find_by_", "")
+          relation.where("#{attribute} = ?", *args).first
+        else
+          super
+        end
+      end
+
+      def new(attributes={})
+        self.alloc.initWithEntity(entityDescription, insertIntoManagedObjectContext:nil).tap do |model|
+          attributes.each do |keyPath, value|
+            model.setValue(value, forKey:keyPath)
+          end
+        end
+      end
+
+      def respond_to?(method)
+        if method.start_with?("find_by_")
+          true
+        else
+          super
+        end
+      end
+
+      def order(*args)
+        relation.order(*args)
+      end
+
+      def where(*args)
+        relation.where(*args)
+      end
+
+    private
+
+      def relation
+        Data::Relation.alloc.initWithClass(self)
+      end
+    end
+
+    def destroy
+      self.class.destroy(self)
+    end
+
+    def inspect
+      properties = entity.properties.map { |property| "#{property.name}: #{valueForKey(property.name).inspect}" }
+
+      "#<#{entity.name} #{properties.join(", ")}>"
+    end
+
+    def save
+      unless context = managedObjectContext
+        context = UIApplication.sharedApplication.delegate.managedObjectContext
+        context.insertObject(self)
+      end
+
+      error = Pointer.new(:object)
+      context.save(error)
+    end
+  end
+end

data/lib/nitron/data/relation.rb

@@ -0,0 +1,59 @@
+module Nitron
+module Data
+  class Relation < NSFetchRequest
+    def initWithClass(entityClass)
+      if init
+        setEntity(entityClass.entityDescription)
+      end
+
+      self
+    end
+
+    def all
+      self
+    end
+
+    def first
+      setFetchLimit(1)
+
+      to_a[0]
+    end
+
+    def inspect
+      to_a
+    end
+
+    def order(column, opts={})
+      descriptors = sortDescriptors || []
+
+      descriptors << NSSortDescriptor.alloc.initWithKey(column.to_s, ascending:opts.fetch(:ascending, true))
+      setSortDescriptors(descriptors)
+
+      self
+    end
+
+    def to_a
+      error = Pointer.new(:object)
+      context.executeFetchRequest(self, error:error)
+    end
+
+    def where(format, *args)
+      predicate = NSPredicate.predicateWithFormat(format.gsub("?", "%@"), argumentArray:args)
+
+      if self.predicate
+        self.predicate = NSCompoundPredicate.andPredicateWithSubpredicates([predicate])
+      else
+        self.predicate = predicate
+      end
+
+      self
+    end
+
+  private
+
+    def context
+      UIApplication.sharedApplication.delegate.managedObjectContext
+    end
+  end
+end
+end

data/lib/nitron/static_table_view_controller.rb

@@ -0,0 +1,38 @@
+module Nitron
+  class StaticTableViewController < ViewController
+    def setValue(value, forKey: key)
+      if key == "staticDataSource"
+        @_dataSource = value
+      else
+        super
+      end
+    end
+
+    def tableView(tableView, didSelectRowAtIndexPath:indexPath)
+      cell = tableView.cellForRowAtIndexPath(indexPath)
+
+      if outlet = cell.outlets.first
+        handler = self.class.outletHandlers[outlet[0]]
+
+        if handler
+          self.instance_eval(&handler[:handler])
+        end
+      end
+    end
+
+    def tableView(tableView, heightForRowAtIndexPath:indexPath)
+      cell = @_dataSource.tableView(tableView, cellForRowAtIndexPath:indexPath)
+
+      cell.bounds.size.height
+    end
+
+    def viewWillAppear(animated)
+      view.dataSource = @_dataSource
+      view.delegate = self
+
+      # The data binding module may wrap view.delegate, so run it after we've set up.
+      super
+    end
+  end
+end
+

data/lib/nitron/table_view_controller.rb

@@ -0,0 +1,172 @@
+module Nitron
+  class TableViewController < ViewController
+    def self.collection(&block)
+      options[:collection] = block
+    end
+
+    def self.group_by(name, opts={})
+      options[:groupBy] = name.to_s
+      options[:groupIndex] = opts[:index] || false
+    end
+
+    def self.options
+      @options ||= {
+        collection: lambda { [] },
+        groupBy:    nil,
+        groupIndex: false,
+      }
+    end
+
+  protected
+
+    def controllerDidChangeContent(controller)
+      view.reloadData()
+    end
+
+    def dataSource
+      @_dataSource ||= begin
+        collection = self.instance_eval(&self.class.options[:collection])
+
+        case collection
+        when Array
+          ArrayDataSource.alloc.initWithCollection(collection, className:self.class.name)
+        when NSFetchRequest
+          CoreDataSource.alloc.initWithRequest(collection, owner:self, sectionNameKeyPath:self.class.options[:groupBy], options:self.class.options)
+        else
+          raise "Collection block must return an Array, or an NSFetchRequest"
+        end
+      end
+    end
+
+    def prepareForSegue(segue, sender:sender)
+      model = nil
+
+      if view.respond_to?(:indexPathForSelectedRow)
+        if view.indexPathForSelectedRow
+          model = dataSource.objectAtIndexPath(view.indexPathForSelectedRow)
+        end
+      end
+
+      if model
+        controller = segue.destinationViewController
+        if controller.respond_to?(:model=)
+          controller.model = model
+        end
+      end
+    end
+
+    def setValue(value, forKey: key)
+      if key == "staticDataSource"
+        raise "Static tables are not supported by TableViewController! Please use StaticTableViewController instead."
+      else
+        super
+      end
+    end
+
+    def viewDidLoad
+      super
+
+      view.dataSource = dataSource
+    end
+
+  protected
+
+    class ArrayDataSource
+      def initWithCollection(collection, className:className)
+        if init
+          @collection = collection
+          @className = className
+        end
+
+        self
+      end
+
+      def numberOfSectionsInTableView(tableView)
+        1
+      end
+
+      def objectAtIndexPath(indexPath)
+        @collection[indexPath.row]
+      end
+
+      def sectionForSectionIndexTitle(title, atIndex:index)
+        nil
+      end
+
+      def tableView(tableView, cellForRowAtIndexPath:indexPath)
+        @cellReuseIdentifier ||= "#{@className.gsub("ViewController", "")}Cell"
+        unless cell = tableView.dequeueReusableCellWithIdentifier(@cellReuseIdentifier)
+          puts "Unable to find a cell named #{@cellReuseIdentifier}. Have you set the reuse identifier of the UITableViewCell?"
+          return
+        end
+
+        cell
+      end
+
+      def tableView(tableView, numberOfRowsInSection:section)
+        @collection.size
+      end
+    end
+
+    class CoreDataSource
+      def initWithRequest(request, owner:owner, sectionNameKeyPath:sectionNameKeyPath, options:options)
+        if init
+          context = UIApplication.sharedApplication.delegate.managedObjectContext
+
+          @className = owner.class.name
+          @controller = NSFetchedResultsController.alloc.initWithFetchRequest(request,
+                                                                              managedObjectContext:context,
+                                                                              sectionNameKeyPath:sectionNameKeyPath,
+                                                                              cacheName:nil)
+          @controller.delegate = owner
+          @options = options
+
+          errorPtr = Pointer.new(:object)
+          unless @controller.performFetch(errorPtr)
+            raise "Error fetching data"
+          end
+        end
+
+        self
+      end
+
+      def numberOfSectionsInTableView(tableView)
+        @controller.sections.size
+      end
+
+      def objectAtIndexPath(indexPath)
+        @controller.objectAtIndexPath(indexPath)
+      end
+
+      def sectionForSectionIndexTitle(title, atIndex:index)
+        @collection.sectionForSectionIndexTitle(title, atIndex:index)
+      end
+
+      def sectionIndexTitlesForTableView(tableView)
+        if @options[:groupIndex]
+          @controller.sectionIndexTitles
+        else
+          nil
+        end
+      end
+
+      def tableView(tableView, cellForRowAtIndexPath:indexPath)
+        @cellReuseIdentifier ||= "#{@className.gsub("ViewController", "")}Cell"
+        unless cell = tableView.dequeueReusableCellWithIdentifier(@cellReuseIdentifier)
+          puts "Unable to find a cell named #{@cellReuseIdentifier}. Have you set the reuse identifier of the UITableViewCell?"
+          return nil
+        end
+
+        cell
+      end
+
+      def tableView(tableView, numberOfRowsInSection:section)
+        @controller.sections[section].numberOfObjects
+      end
+
+      def tableView(tableView, titleForHeaderInSection:section)
+        @controller.sections[section].name
+      end
+    end
+  end
+end

data/lib/nitron/ui/action_support.rb

@@ -0,0 +1,49 @@
+module Nitron
+module UI
+  module ActionSupport
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def on(outlet, &block)
+        actions[outlet.to_s] = { :handler => block }
+      end
+
+      def actions
+        @_actions ||= {
+          "cancel" => { :handler => proc { close }, :default => true },
+          "done"   => { :handler => proc { close }, :default => true }
+        }
+      end
+    end
+
+    def _dispatch(sender)
+      if action = @_actions[sender]
+        instance_eval &action[:handler]
+      end
+    end
+
+    def dealloc
+      @_actions.clear
+
+      super
+    end
+
+    def viewDidLoad
+      super
+
+      @_actions = {}
+
+      self.class.actions.each do |outlet, action|
+        if respond_to?(outlet)
+          target = send(outlet)
+          @_actions[target] = self.class.actions[outlet]
+
+          target.addTarget(self, action:"_dispatch:", forControlEvents:UIControlEventTouchUpInside)
+        end
+      end
+    end
+  end
+end
+end

data/lib/nitron/ui/data_binder.rb

@@ -0,0 +1,49 @@
+module Nitron
+module UI
+  class DataBinder
+    def self.shared
+      @singleton ||= alloc.init
+    end
+
+    def bind(model, view, options={})
+      if view.is_a?(UITableView)
+        view.delegate = DataBoundTableDelegate.alloc.initWithDelegate(view.delegate)
+        return [view.delegate]
+      end
+
+      view.dataBindings.each do |keyPath, subview|
+        bindControl(model, subview, keyPath)
+      end
+
+      nil
+    end
+
+  private
+
+    def bindControl(model, control, keyPath)
+      value = model.valueForKeyPath(keyPath)
+
+      if control.respond_to?(:text=)
+        control.text = value
+      elsif control.respond_to?(:image=)
+        control.image = value
+      elsif control.respond_to?(:value=)
+        control.value = value
+      elsif control.respond_to?(:on=)
+        control.on = value
+      elsif control.respond_to?(:progress=)
+        control.progress = value
+      elsif control.respond_to?(:date=)
+        control.date = value
+      else
+        puts "Sorry, data binding is not supported for an instance of '#{control.class.name}' :("
+      end
+
+    rescue
+      puts "***ERROR: Failed to bind value #{value.inspect} (read from '#{model.class.name}.#{keyPath}') to #{control.inspect}"
+
+      raise
+    end
+  end
+end
+end

data/lib/nitron/ui/data_binding_support.rb

@@ -0,0 +1,33 @@
+module Nitron
+module UI
+  module DataBindingSupport
+    def dealloc
+      if @_bindings
+        @_bindings = nil
+      end
+
+      if @_model
+        @_model = nil
+      end
+
+      super
+    end
+
+    def model
+      @_model
+    end
+
+    def model=(model)
+      @_model = model
+
+      DataBinder.shared.bind(model, view)
+    end
+
+    def viewDidLoad
+      super
+
+      @_bindings = DataBinder.shared.bind(model, view)
+    end
+  end
+end
+end

data/lib/nitron/ui/data_bound_table_delegate.rb

@@ -0,0 +1,41 @@
+module Nitron
+module UI
+  class DataBoundTableDelegate
+    def initWithDelegate(delegate)
+      if init
+        @delegate = delegate
+      end
+
+      self
+    end
+
+    def method_missing(method, *args, &block)
+      if @delegate
+        @delegate.send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to?(method)
+      if method == "tableView:willDisplayCell:forRowAtIndexPath"
+        true
+      elsif @delegate
+        @delegate.respond_to?(method)
+      else
+        super
+      end
+    end
+
+    def tableView(tableView, willDisplayCell:cell, forRowAtIndexPath:indexPath)
+      if @delegate && @delegate.respond_to?("tableView:willDisplayCell:forRowAtIndexPath:")
+        @delegate.tableView(tableView, willDisplayCell:cell, forRowAtIndexPath:indexPath)
+      end
+
+      model = tableView.dataSource.objectAtIndexPath(indexPath)
+
+      Nitron::UI::DataBinder.shared.bind(model, cell)
+    end
+  end
+end
+end

data/lib/nitron/ui/extensions/app_delegate+storyboard.rb

@@ -0,0 +1,19 @@
+class AppDelegate
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+    @window = UIWindow.alloc.initWithFrame(UIScreen.mainScreen.bounds)
+
+    if storyboard
+      @window.rootViewController = storyboard.instantiateInitialViewController
+    end
+
+    @window.rootViewController.wantsFullScreenLayout = true
+    @window.makeKeyAndVisible
+
+    true
+  end
+
+  def storyboard
+    @storyboard ||= UIStoryboard.storyboardWithName("MainStoryboard", bundle:nil)
+  end
+end
+

data/lib/nitron/ui/extensions/ui_bar_button_item.rb

@@ -0,0 +1,9 @@
+class UIBarButtonItem
+  def setValue(value, forUndefinedKey:key)
+    if key == "outlet"
+      view.setValue(value, forUndefinedKey:key)
+    else
+      super
+    end
+  end
+end

data/lib/nitron/ui/extensions/ui_view.rb

@@ -0,0 +1,32 @@
+class UIView
+  def dataBindings
+    @_dataBindings ||= {}
+  end
+
+  def outlets
+    @_outlets ||= {}
+  end
+
+  def setValue(value, forUndefinedKey:key)
+    if key == "dataBinding" || key == "outlet"
+      raise "Runtime attribute '#{key}' must be a String (declared on #{self.class.name})" unless value.is_a?(String)
+
+      container = self
+      while container.superview
+        container = container.superview
+      end
+
+      if key == "dataBinding"
+        unless value.start_with?("model.")
+         raise "Data binding expression must start with 'model.'; you provided '#{value}'"
+        end
+
+        container.dataBindings[value[6..-1]] = self
+      else
+        container.outlets[value] = self
+      end
+    else
+      super
+    end
+  end
+end

data/lib/nitron/ui/outlet_binder.rb

@@ -0,0 +1,12 @@
+module Nitron
+module UI
+  class OutletBinder
+    def bind(controller, view)
+      # Emulate IB's outlets by using KVC.
+      view.outlets.each do |outlet, subview|
+        controller.setValue(subview, forKey:outlet)
+      end
+    end
+  end
+end
+end

data/lib/nitron/ui/outlet_support.rb

@@ -0,0 +1,20 @@
+module Nitron
+module UI
+  module OutletSupport
+    def setValue(value, forUndefinedKey:key)
+      unless self.class.respond_to?(key)
+        self.class.send(:attr_reader, key)
+      end
+
+      instance_variable_set("@#{key}", value)
+    end
+
+    def viewDidLoad
+      super
+
+      outletBinder = OutletBinder.new
+      outletBinder.bind(self, view)
+    end
+  end
+end
+end

data/lib/nitron/version.rb

@@ -0,0 +1,3 @@
+module Nitron
+  VERSION = "0.2"
+end

data/lib/nitron/view_controller.rb

@@ -0,0 +1,12 @@
+module Nitron
+  class ViewController < UIViewController
+    include UI::DataBindingSupport
+    include UI::OutletSupport
+    include UI::ActionSupport
+
+    def close
+      dismissModalViewControllerAnimated(true)
+    end
+  end
+end
+

data/nitron.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/nitron/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Matt Green"]
+  gem.email         = ["mattgreenrocks@gmail.com"]
+  gem.description   = "Turbocharged iOS development via RubyMotion"
+  gem.summary       = "Turbocharged iOS development via RubyMotion"
+  gem.homepage      = "https://github.com/mattgreen/nitron"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "nitron"
+  gem.require_paths = ["lib"]
+  gem.version       = Nitron::VERSION
+
+  gem.add_dependency 'motion-cocoapods', '>= 1.0.1'
+end

data/spec/main_spec.rb

@@ -0,0 +1,9 @@
+describe "Application 'spry'" do
+  before do
+    @app = UIApplication.sharedApplication
+  end
+
+  it "has one window" do
+    @app.windows.size.should == 1
+  end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: nitron
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  version: "0.2"
+platform: ruby
+authors: 
+- Matt Green
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-12 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: motion-cocoapods
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 1
+        version: 1.0.1
+  type: :runtime
+  version_requirements: *id001
+description: Turbocharged iOS development via RubyMotion
+email: 
+- mattgreenrocks@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- README.md
+- lib/nitron.rb
+- lib/nitron/data/extensions/app_delegate+core_data.rb
+- lib/nitron/data/model.rb
+- lib/nitron/data/relation.rb
+- lib/nitron/static_table_view_controller.rb
+- lib/nitron/table_view_controller.rb
+- lib/nitron/ui/action_support.rb
+- lib/nitron/ui/data_binder.rb
+- lib/nitron/ui/data_binding_support.rb
+- lib/nitron/ui/data_bound_table_delegate.rb
+- lib/nitron/ui/extensions/app_delegate+storyboard.rb
+- lib/nitron/ui/extensions/ui_bar_button_item.rb
+- lib/nitron/ui/extensions/ui_view.rb
+- lib/nitron/ui/outlet_binder.rb
+- lib/nitron/ui/outlet_support.rb
+- lib/nitron/version.rb
+- lib/nitron/view_controller.rb
+- nitron.gemspec
+- spec/main_spec.rb
+has_rdoc: true
+homepage: https://github.com/mattgreen/nitron
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Turbocharged iOS development via RubyMotion
+test_files: 
+- spec/main_spec.rb