quickie_motion 0.1.0

data/.gitignore

@@ -0,0 +1,27 @@
+# Mac OS
+.DS_Store
+
+# TextMate
+*.tmproj
+tmtags
+
+# Emacs
+*~
+\#*
+.\#*
+
+# Vim
+*.swp
+
+# Gem
+coverage
+rdoc
+pkg
+.rvmrc
+
+# Test
+test/.repl_history
+test/build
+test/resources/*.nib
+test/resources/*.momd
+test/resources/*.storyboardc

data/CHANGELOG

@@ -0,0 +1,2 @@
+0.1.0
+  - Initial RubyMotion implementation based on Quickie 0.3.0 gem.

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011-2012 Michael Dvorkin
+twitter.com/mid
+%w(mike dvorkin.net) * "@" || %w(mike fatfreecrm.com) * "@"
+
+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,85 @@
+## Quickie for RubyMotion ##
+Quickie for RubyMotion is a gem for quick in-place testing of your RubyMotion code. It provides
+four useful methods:
+
+* <code>Object#should</code> and <code>Object#should\_not</code> for positive and negative assertions.
+* <code>Object#stub</code> for method stubbing.
+* <code>Kernel#mock</code> for creating object mocks.
+
+### Installation ###
+    # Installing as Ruby gem
+    $ gem install quickie_motion
+
+    # Cloning the repository
+    $ git clone git://github.com/michaeldv/quickie_motion.git
+
+### Usage ###
+Generate RubyMotion project, then require "quickie_motion" in projects's Rakefile:
+
+    # -*- coding: utf-8 -*-
+    $:.unshift("/Library/RubyMotion/lib")
+    require "motion/project"
+    require "quickie_motion"
+
+    Motion::Project::App.setup do |app|
+      app.name = "your_app_name"
+    end
+
+Add your Quickie tests to the AppDelegate as follows:
+
+    class AppDelegate
+      def application(application, didFinishLaunchingWithOptions:launchOptions)
+        #
+        # Your application code.
+        #
+        return true if RUBYMOTION_ENV == "release"
+        #
+        # Your tests.
+        #
+        quickie do
+          run_tests
+          run_more_tests
+        end 
+      end
+
+      private
+
+      def run_tests
+        1.should == 1
+      end
+
+      def run_more_tests
+        true.should_not == false
+      end
+    end
+
+For more information about the usage of assertions and stubs please check http://github.com/michaeldv/quickie.
+
+### Testing Quickie for RubyMotion ###
+Quickie code is tested by the Quickie itself.
+
+    $ rake quickie
+         Build ./build/iPhoneSimulator-6.0-Development
+      Simulate ./build/iPhoneSimulator-6.0-Development/quickie_motion_test.app
+    .....................................
+
+    Passed: 37, not quite: 0, total tests: 37.
+    (main)>
+
+For more details please check <code>quickie_motion_test</code> application in the <code>test</code> directory.
+
+### Note on Patches/Pull Requests ###
+* Fork the project on Github.
+* Make your feature addition or bug fix.
+* Add tests for it making sure $ rake quickie passes 100%.
+* Commit, do not mess with Rakefile, version, or history.
+* Send me commit URL (*do not* send pull requests).
+
+### License ###
+Copyright (c) 2010-2012 Michael Dvorkin
+
+http://www.dvorkin.net
+
+%w(mike dvorkin.net) * "@" || %w(mike fatfreecrm.com) * "@"
+
+Released under the MIT license. See LICENSE file for details.

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+desc "Build quickie tests and run them"
+task :quickie do
+  system "cd ./test && rake && cd .."
+end

data/lib/quickie_motion.rb

@@ -0,0 +1,19 @@
+# Copyright (c) 2011-12 Michael Dvorkin
+#
+# Quickie is freely distributable under the terms of MIT license.
+# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+Motion::Project::App.setup do |app|
+  dir = File.dirname(__FILE__)
+  app.files.unshift("#{dir}/quickie_motion/core_ext/kernel.rb")
+  app.files.unshift("#{dir}/quickie_motion/core_ext/object.rb")
+  app.files.unshift("#{dir}/quickie_motion/runner.rb")
+  app.files.unshift("#{dir}/quickie_motion/matcher.rb")
+  app.files.unshift("#{dir}/quickie_motion/stub.rb")
+  app.files.unshift("#{dir}/quickie_motion/mock.rb")
+  app.files.unshift("#{dir}/quickie_motion/version.rb")
+end

data/lib/quickie_motion/core_ext/kernel.rb

@@ -0,0 +1,20 @@
+# Copyright (c) 2011-2012 Michael Dvorkin
+#
+# Awesome Print is freely distributable under the terms of MIT license.
+# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+module Kernel
+  def quckie
+    current, Exception.log_exceptions = Exception.log_exceptions, false
+    yield
+    Quickie::Runner.summary
+  ensure
+    Exception.log_exceptions = current
+  end
+
+  def mock
+    Quickie::Mock.new
+  end
+
+  module_function :quckie, :mock
+end

data/lib/quickie_motion/core_ext/object.rb

@@ -0,0 +1,28 @@
+# Copyright (c) 2011-12 Michael Dvorkin
+#
+# Quickie is freely distributable under the terms of MIT license.
+# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+class Object
+  [ :should, :should_not ].each do |verb|
+    define_method verb do
+      Quickie::Matcher.new(self, verb)
+    end
+    alias_method :"#{verb}_be", verb
+  end
+
+  define_method :stub do |method, options = {}|
+    Quickie::Stub.new(self, method, options)
+  end
+  alias_method :stub!, :stub
+  #
+  # Define Object#singleton_class since it's not there (as of RubyMotion 1.26).
+  #
+  unless self.method_defined?(:singleton_class)
+    def singleton_class
+      class << self
+        self
+      end
+    end
+  end
+end

data/lib/quickie_motion/matcher.rb

@@ -0,0 +1,82 @@
+# Copyright (c) 2011-12 Michael Dvorkin
+#
+# Quickie is freely distributable under the terms of MIT license.
+# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+module Quickie
+  class Hell < RuntimeError
+    def oops
+      "#{message.chomp} in #{backtrace[2].sub(':', ', line ').sub(':', ' ')}"
+    end
+  end
+
+  class Matcher
+    def initialize(object, verb)
+      @object = object
+      @should = (verb == :should)
+    end
+
+    private
+
+    # Override an operator to be able to tell whether it succeeded or not.
+    #--------------------------------------------------------------------------
+    def self.override(operator)
+      define_method(operator) do |expected|
+        evaluate(operator, nil, expected)
+      end
+
+      negative_operator = case operator[0]
+      when '<' then operator.sub('<',  '>')
+      when '>' then operator.sub('>',  '<')
+      else          operator.sub(/^=/, '!')
+      end
+
+      return unless @object.respond_to?(negative_operator)
+
+      define_method(negative_operator) do |expected|
+        evaluate(operator, negative_operator, expected)
+      end
+    end
+
+    # Note that we always evaluate positive operators, and then flip the actual
+    # result based on should/should_not request.
+    #--------------------------------------------------------------------------
+    def evaluate(operator, negative_operator, expected)
+      actual = !!@object.__send__(operator, expected)
+      actual ^= 1 if (!@should && !negative_operator) || (@should && negative_operator)
+
+      if actual
+        report :success
+      else
+        raise Hell, lyrics(negative_operator || operator, expected)
+      end
+
+    rescue Hell => e
+      report :failure, e.oops
+    end
+
+    # Format actual vs. expected message.
+    #--------------------------------------------------------------------------
+    def lyrics(operator, expected)
+      format = "expected: %s %s\n  actual: %s %s"
+      format.sub!(":", " not:").sub!("\n", "\n    ") unless @should
+      format % [ operator, expected.inspect, ' ' * operator.size, @object.inspect ]
+    end
+
+    # Report test success and/or failure. When running within IRB or Pry the
+    # message gets displayed immediately, otherwise all the messages are shown
+    # by the Runner in at_exit block.
+    #--------------------------------------------------------------------------
+    def report(status, message = nil)
+      print(status == :success ? '.' : 'F') unless ENV["quickie_motion_test"]
+      Runner.update(status, message)
+      status == :success
+    end
+
+    # The matcher magic starts here ;-)
+    #--------------------------------------------------------------------------
+    %w[ == === =~ > >= < <= => ].each do |operator|
+      override operator
+    end
+  end
+end

data/lib/quickie_motion/mock.rb

@@ -0,0 +1,62 @@
+# Copyright (c) 2011-12 Michael Dvorkin
+#
+# Quickie is freely distributable under the terms of MIT license.
+# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+module Quickie
+  class Mock
+    alias :__methods     :methods
+    alias :__respond_to? :respond_to?
+
+    begin
+      current, Exception.log_exceptions = Exception.log_exceptions, false
+      instance_methods.each do |method|
+        unless method =~ /(?:__|:)/ || [ :==, :===, :!=, :ai, :class, :object_id, :respond_to_missing?, :to_s ].include?(method)
+          undef_method method rescue nil # Suppress cannot undefine method `???' because it is a native method (RuntimeError)
+        end
+      end
+    ensure
+      Exception.log_exceptions = current
+    end
+
+    def initialize
+      @stash = {}
+    end
+
+    def stub(method, options = {})
+      unless __methods.include?(method)
+        options[:return] ||= nil
+        @stash[method] = options
+      else
+        super(method, options)
+      end
+      self
+    end
+    alias :stub! :stub
+
+    def inspect
+      self.to_s
+    end
+
+    def instance_variables
+      []
+    end
+
+    def methods
+      (__methods - [ :__methods, :__respond_to?, :instance_variables, :respond_to_missing? ] + @stash.keys).sort
+    end
+
+    def method_missing(method, *args)
+      if @stash.key?(method) then
+        @stash[method][:return]
+      else
+        raise NoMethodError, "undefined method `%s', expected one of %p" % [ method, methods ]
+      end
+    end
+
+    def respond_to?(method)
+      return true if @stash.key?(method.to_sym)
+      __respond_to?(method)
+    end
+  end
+end

data/lib/quickie_motion/runner.rb

@@ -0,0 +1,30 @@
+# Copyright (c) 2011-12 Michael Dvorkin
+#
+# Quickie is freely distributable under the terms of MIT license.
+# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+module Quickie
+  class Runner
+
+    class << self
+      def reset
+        @trace = []
+        @stats = Hash.new(0)
+      end
+
+      def update(status, message = nil)
+        @stats[status] += 1
+        @trace << message if message
+      end
+
+      def summary
+        puts
+        puts "\n" << @trace.join("\n\n") unless @trace.empty?
+        puts "\nPassed: #{@stats[:success]}, not quite: #{@stats[:failure]}, total tests: #{@stats.values.inject(:+)}."
+        reset
+      end
+    end
+
+    reset
+  end
+end

data/lib/quickie_motion/stub.rb

@@ -0,0 +1,109 @@
+# Copyright (c) 2011-12 Michael Dvorkin
+#
+# Quickie is freely distributable under the terms of MIT license.
+# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+module Quickie
+  class Stub
+    #
+    # To set up a stub with optional return value:
+    #   obj.stub(:method, :return => something)
+    #
+    # To remove existing stub and restore original method:
+    #   obj.stub(:method, :remove)
+    #
+    #--------------------------------------------------------------------------
+    def initialize(object, method, options = {})
+      options = { options => true } if options.is_a?(Symbol)
+      @object, @options = object, options
+      @@stash ||= []
+      #
+      # Create a new stub by intercepting the method or remove existing stub
+      # by restoring the original method.
+      #
+      unless @options[:remove]
+        intercept(method)
+      else
+        restore(method)
+      end
+    end
+
+    private
+
+    # Same as class << @object; self; end -- comes with Ruby 1.9.
+    #--------------------------------------------------------------------------
+    def metaclass
+      @object.singleton_class
+    end
+
+    # Unique name the original method gets stashed under when creating a stub.
+    #--------------------------------------------------------------------------
+    def moniker(method)
+      :"__#{method}__#{@object.__id__}"
+    end
+
+    # Return method's visibility, nil if public.
+    #--------------------------------------------------------------------------
+    def visibility(method)
+      if metaclass.private_method_defined?(method)
+        :private
+      elsif metaclass.protected_method_defined?(method)
+        :protected
+      end
+    end
+
+    # Set up a stub by stashing the original method under different name and
+    # then rediefining the method to return the requested value.
+    #--------------------------------------------------------------------------
+    def intercept(method)
+      new_name = moniker(method)
+      unless @object.respond_to? new_name
+        stash(method, new_name)
+        redefine(method)
+      end
+    end
+
+    # Preserve original method by creating its alias with the unique name.
+    #--------------------------------------------------------------------------
+    def stash(method, new_name)
+      metaclass.class_eval do
+        if method_defined?(method) || private_method_defined?(method)
+          alias_method new_name, method
+        end
+      end
+      @@stash << new_name
+    end
+
+    # Create a stub that returns requested value.
+    #--------------------------------------------------------------------------
+    def redefine(method)
+      return_value = @options[:return]
+      metaclass.class_eval do
+        define_method method do |*args, &block|
+          return_value
+        end
+      end
+      #
+      # Set visibility attribute if the origial method is not public.
+      #
+      private_or_protected = visibility(method)
+      metaclass.class_eval("#{private_or_protected} :#{method}") if private_or_protected
+    end
+
+    # Remove the stub and restore the original method.
+    #--------------------------------------------------------------------------
+    def restore(method)
+      stashed_name = moniker(method)
+      if @@stash.include? stashed_name          # Was it ever stubbed?
+        metaclass.instance_eval do
+          if method_defined?(stashed_name) || private_method_defined?(stashed_name)
+            remove_method method                # Remove the stub.
+            alias_method method, stashed_name   # Restore the original method from stash.
+            remove_method stashed_name          # Remove stashed copy.
+          end
+        end
+        @@stash.delete stashed_name
+      end
+    end
+  end
+end

data/lib/quickie_motion/version.rb

@@ -0,0 +1,10 @@
+# Copyright (c) 2011-12 Michael Dvorkin
+#
+# Quickie is freely distributable under the terms of MIT license.
+# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+module Quickie
+  def self.version
+    "0.1.0"
+  end
+end

data/test/Rakefile

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+$:.unshift("/Library/RubyMotion/lib")
+require "motion/project"
+require File.expand_path(File.dirname(__FILE__) + "/../lib/quickie_motion")
+
+Motion::Project::App.setup do |app|
+  app.name = "quickie_motion_test"
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: quickie_motion
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Michael Dvorkin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Quickie adds Object#should, Object#should_not, and Object#stub methods
+  for quick and easy testing of your RubyMotion code
+email: mike@dvorkin.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG
+- Gemfile
+- LICENSE
+- Rakefile
+- README.md
+- lib/quickie_motion/core_ext/kernel.rb
+- lib/quickie_motion/core_ext/object.rb
+- lib/quickie_motion/matcher.rb
+- lib/quickie_motion/mock.rb
+- lib/quickie_motion/runner.rb
+- lib/quickie_motion/stub.rb
+- lib/quickie_motion/version.rb
+- lib/quickie_motion.rb
+- .gitignore
+- test/Rakefile
+homepage: http://github.com/michaeldv/quickie_motion
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1131033836946887671
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1131033836946887671
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Micro framework for in-place testing of RubyMotion code
+test_files:
+- test/Rakefile