toki 0.0.2 → 0.0.3

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - "1.8.7"
+  - "1.9.2"
+  - "1.9.3"
+  - "2.0.0"
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-18mode
+  - rbx-19mode

data/Gemfile

@@ -2,3 +2,9 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in toki.gemspec
 gemspec
+
+gem 'rake'
+
+# if defined?(Rubinius)
+#   gem 'rubysl-test-unit'
+# end

data/README.md

@@ -1,4 +1,4 @@
-# Toki
+# Toki [![Gem Version](https://badge.fury.io/rb/toki.png)](http://badge.fury.io/rb/toki) [![Build Status](https://travis-ci.org/juskoljo/toki.png?branch=master)](https://travis-ci.org/juskoljo/toki)
 
 Toki is a DSL that helps you to implement Ruby version, patchlevel, engine and platform specific code
 
@@ -21,7 +21,7 @@ Or install it yourself as:
 ```ruby
 require 'toki'
 
-class Example
+class Example1
   extend Toki
 
   def self.ping
@@ -35,7 +35,7 @@ class Example
   end
 
   # any mri version of ruby that is 1.9 or later
-  when_ruby :engine => 'ruby', :version => /^((?!1\.[0-8]).*?)$/ do
+  when_ruby :engine => :ruby, :version => /^(?!1\.[0-8]).*$/ do
     # also class methods can be defined
     def self.ping
       "gnop"
@@ -51,17 +51,29 @@ class Example
   when_ruby :version => '1.8.7',    :patchlevel       => '371'    do; end
 
   # applied only if engine and version matches
-  when_ruby :engine  => 'ruby',     :version          => '1.8.7'  do; end
-  when_ruby :engine  => 'jruby',    :jruby_version    => '1.7.6'  do; end
-  when_ruby :engine  => 'macruby',  :macruby_version  => '0.12'   do; end
-  when_ruby :engine  => 'rbx',      :rbx_version      => '2.1.1'  do; end
-  when_ruby :engine  => 'maglev',   :maglev_version   => '1.1RC1' do; end
-  when_ruby :engine  => 'ironruby', :ironruby_version => '1.1.3'  do; end
-  when_ruby :engine  => 'kiji',     :kiji_version     => '0.11'   do; end
+  when_ruby :engine  => :ruby,      :version          => '1.8.7'  do; end
+  when_ruby :engine  => "ruby",     :version          => '1.8.7'  do; end
+
+  # notice that /ruby/ will match with both "ruby" and "jruby"
+  when_ruby :engine  => /^ruby$/,   :version          => '1.8.7'  do; end
+
+  when_ruby :engine  => :jruby,     :jruby_version    => '1.7.6'  do; end
+  when_ruby :engine  => :macruby,   :macruby_version  => '0.12'   do; end
+  when_ruby :engine  => :rbx,       :rbx_version      => '2.1.1'  do; end
+  when_ruby :engine  => :maglev,    :maglev_version   => '1.1RC1' do; end
+  when_ruby :engine  => :ironruby,  :ironruby_version => '1.1.3'  do; end
+  when_ruby :engine  => :kiji,      :kiji_version     => '0.11'   do; end
+
+  # apply only if matches with one of the engines
+  when_ruby :engine  => [:ruby, :jruby]     do; end
+
+  # apply only if matches with one of the engines
+  when_ruby :version => ['1.8.7', '2.0.0']  do; end
 
   # applied only if platform matches; :windows, :osx, :linux, :unix, :unknown
   when_ruby :platform => :linux         do; end
   when_ruby :platform => /linux/        do; end
+  when_ruby :platform => "linux"        do; end
 
   # alternative method to specify ruby version specific implementation
   when_ruby_version     '2.0.0'         do; end
@@ -71,19 +83,39 @@ class Example
   when_maglev_version   '1.1RC1'        do; end
   when_ironruby_version '1.1.3'         do; end
   when_kiji_version     '0.11'          do; end
-  when_ruby_patchlevel  '371'           do; end
-  when_ruby_engine      'rbx'           do; end
+  when_ruby_patchlevel  371             do; end
+  when_ruby_engine      :rbx            do; end
   when_platform         :osx            do; end
 
 end
 
+class Example2
+  include Toki
+  def array_to_string
+    when_ruby_engine :ruby do
+      when_ruby :version => /^(?!1\.[0-8]).*$/ do
+        # MRI 1.9.x or later
+        return [1,2,3].join
+      end
+      # MRI 1.8.7
+      return [1,2,3].to_s
+    end
+    "321"
+  end
+end
+
 # MRI 1.8.7
-puts Example.ping                 # => "pong"
-puts Example.new.array_to_string  # => "123"
+puts Example1.ping                 # => "pong"
+puts Example1.new.array_to_string  # => "123"
+puts Example2.new.array_to_string  # => "123"
 
 # MRI 2.0.0
-puts Example.ping                 # => "gnop"
-puts Example.new.array_to_string  # => "123"
+puts Example1.ping                 # => "gnop"
+puts Example1.new.array_to_string  # => "123"
+puts Example2.new.array_to_string  # => "123"
+
+# e.g. JRuby or any other engine
+puts Example2.new.array_to_string  # => "321"
 ```
 
 ## Contributing

data/Rakefile

@@ -4,12 +4,10 @@ require "rake/testtask"
 
 task :default => :test
 
-desc "Run unit tests"
-task :test do
-  Rake::TestTask.new { | task |
-    task.pattern = 'test/test_*.rb'
-    task.verbose = true
-    task.options = '-v'
-    task.warning = false
-  }
+# :test
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/test_*.rb']
+  t.options = '-v'
+  t.verbose = true
 end

data/changelog

@@ -1,3 +1,12 @@
+Sun Oct 27 22:29:21 +0200 2013  Jussi Koljonen  <jussi.koljonen@gmail.com>
+
+    * Toki version 0.0.3 changes:
+
+      * Toki can be included to Class/Module and called from instance methods
+      * Added support for Array and Symbol arguments; e.g. :engine => [:ruby, 'jruby']
+      * Added more platforms to host_os detection; "msdos" and "djgpp" (windows)
+      * Minor internal refactoring
+
 Sun Oct 27 12:42:47 +0200 2013  Jussi Koljonen  <jussi.koljonen@gmail.com>
 
     * Toki version 0.0.2 changes:

data/lib/toki.rb

@@ -34,9 +34,9 @@ module Toki
   end
 
   # JRUBY_VERSION
-  def when_jruby_version(pattern, &block)
+  def when_jruby_version(value, &block)
     if defined?(JRUBY_VERSION)
-      if pattern_matches_with?(JRUBY_VERSION, pattern)
+      if value_matches_with?(value, JRUBY_VERSION)
         apply_behaviour(&block)
       else
         false
@@ -48,9 +48,9 @@ module Toki
   end
 
   # MACRUBY_VERSION
-  def when_macruby_version(pattern, &block)
+  def when_macruby_version(value, &block)
     if defined?(MACRUBY_VERSION)
-      if pattern_matches_with?(MACRUBY_VERSION, pattern)
+      if value_matches_with?(value, MACRUBY_VERSION)
         apply_behaviour(&block)
       else
         false
@@ -62,9 +62,9 @@ module Toki
   end
 
   # Rubinius::VERSION
-  def when_rbx_version(pattern, &block)
+  def when_rbx_version(value, &block)
     if defined?(Rubinius)
-      if pattern_matches_with?(Rubinius::VERSION, pattern)
+      if value_matches_with?(value, Rubinius::VERSION)
         apply_behaviour(&block)
       else
         false
@@ -76,9 +76,9 @@ module Toki
   end
 
   # MAGLEV_VERSION
-  def when_maglev_version(pattern, &block)
+  def when_maglev_version(value, &block)
     if defined?(MAGLEV_VERSION)
-      if pattern_matches_with?(MAGLEV_VERSION, pattern)
+      if value_matches_with?(value, MAGLEV_VERSION)
         apply_behaviour(&block)
       else
         false
@@ -90,9 +90,9 @@ module Toki
   end
 
   # IRONRUBY_VERSION
-  def when_ironruby_version(pattern, &block)
+  def when_ironruby_version(value, &block)
     if defined?(IRONRUBY_VERSION)
-      if pattern_matches_with?(IRONRUBY_VERSION, pattern)
+      if value_matches_with?(value, IRONRUBY_VERSION)
         apply_behaviour(&block)
       else
         false
@@ -104,9 +104,9 @@ module Toki
   end
 
   # KIJI_VERSION
-  def when_kiji_version(pattern, &block)
+  def when_kiji_version(value, &block)
     if defined?(KIJI_VERSION)
-      if pattern_matches_with?(KIJI_VERSION, pattern)
+      if value_matches_with?(value, KIJI_VERSION)
         apply_behaviour(&block)
       else
         false
@@ -118,8 +118,8 @@ module Toki
   end
 
   # RUBY_VERSION
-  def when_ruby_version(pattern, &block)
-    if pattern_matches_with?(RUBY_VERSION, pattern)
+  def when_ruby_version(value, &block)
+    if value_matches_with?(value, RUBY_VERSION)
       apply_behaviour(&block)
     else
       false
@@ -127,8 +127,8 @@ module Toki
   end
 
   # RUBY_PATCHLEVEL
-  def when_ruby_patchlevel(pattern, &block)
-    if pattern_matches_with?(RUBY_PATCHLEVEL, pattern)
+  def when_ruby_patchlevel(value, &block)
+    if value_matches_with?(value, RUBY_PATCHLEVEL)
       apply_behaviour(&block)
     else
       false
@@ -136,10 +136,10 @@ module Toki
   end
 
   # RUBY_ENGINE
-  def when_ruby_engine(pattern, &block)
+  def when_ruby_engine(value, &block)
     # ruby 1.8.7 does not have RUBY_ENGINE constant
     ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
-    if pattern_matches_with?(ruby_engine, pattern)
+    if value_matches_with?(value, ruby_engine)
       apply_behaviour(&block)
     else
       false
@@ -147,16 +147,16 @@ module Toki
   end
 
   # RUBY_PLATFORM
-  def when_platform(pattern, &block)
-    case pattern
+  def when_platform(value, &block)
+    case value
     when Symbol
-      if pattern == detect_os
+      if value == detect_os
         apply_behaviour(&block)
       else
         false
       end
     else
-      if pattern_matches_with?(RbConfig::CONFIG['host_os'], pattern)
+      if value_matches_with?(value, RbConfig::CONFIG['host_os'])
         apply_behaviour(&block)
       else
         false
@@ -168,7 +168,7 @@ module Toki
 
   def detect_os    
     case RbConfig::CONFIG['host_os']
-    when /mswin|msys|mingw|windows|win32|cygwin|bccwin|wince|emc/i
+    when /msdos|mswin|msys|djgpp|mingw|windows|win32|cygwin|bccwin|wince|emc/i
       :windows
     when /darwin|mac os/i
       :osx
@@ -181,20 +181,31 @@ module Toki
     end
   end
 
-  def pattern_matches_with?(constant, pattern)
-    constant.to_s =~ case pattern
+  def value_matches_with?(value, other)
+    case value
     when String, Integer
-      Regexp.union(pattern.to_s)
+      value.to_s == other.to_s
     when Regexp
-      pattern
+      value =~ other
+    when Array
+      value.any?{|item| value_matches_with?(item, other)}
+    when Symbol
+      value == other.to_sym
     else
-      raise ArgumentError, "wrong argument type #{pattern.class} (expected String or Regexp)"
+      raise ArgumentError, "wrong argument type #{value.class} (expected String, Regexp, Array or Symbol)"
     end
   end
 
   # apply behaviour to target class
   def apply_behaviour(&block)
-    class_eval(&block) if block_given?
+    if block_given?
+      case self
+      when Class, Module
+        class_eval(&block) 
+      else
+        instance_eval(&block)
+      end
+    end
     true
   end
 

data/test/test_toki.rb

@@ -28,15 +28,17 @@ class TestToki < Test::Unit::TestCase
   end
 
   def test_jruby_version
-    unless (jruby_version_defined = defined?(JRUBY_VERSION))
-      Object.const_set(:JRUBY_VERSION, '1.7.4')
+    if (jruby_version_defined = defined?(JRUBY_VERSION))
+      version = JRUBY_VERSION
+    else
+      Object.const_set(:JRUBY_VERSION, (version = 'x.x.x'))
     end
     klass = Class.new do
       extend Toki
       def hello
         nil
       end
-      when_ruby :jruby_version => '1.7.4' do
+      when_ruby :jruby_version => version do
         def hello
           "world"
         end
@@ -49,9 +51,11 @@ class TestToki < Test::Unit::TestCase
   end
 
   def test_rbx_version
-    unless (rbx_defined = defined?(Rubinius))
+    if (rbx_defined = defined?(Rubinius))
+      version = Rubinius::VERSION
+    else
       klass = Class.new
-      klass.const_set(:VERSION, '2.1.1')
+      klass.const_set(:VERSION, (version = 'x.x.x'))
       Object.const_set(:Rubinius, klass)
     end
     klass = Class.new do
@@ -59,7 +63,7 @@ class TestToki < Test::Unit::TestCase
       def hello
         nil
       end
-      when_ruby :rbx_version => '2.1.1' do
+      when_ruby :rbx_version => version do
         def hello
           "world"
         end
@@ -72,15 +76,17 @@ class TestToki < Test::Unit::TestCase
   end
 
   def test_macruby_version
-    unless (macruby_version_defined = defined?(MACRUBY_VERSION))
-      Object.const_set(:MACRUBY_VERSION, '0.12')
+    if (macruby_version_defined = defined?(MACRUBY_VERSION))
+      version = MACRUBY_VERSION
+    else
+      Object.const_set(:MACRUBY_VERSION, (version = 'x.x.x'))
     end
     klass = Class.new do
       extend Toki
       def hello
         nil
       end
-      when_ruby :macruby_version => '0.12' do
+      when_ruby :macruby_version => version do
         def hello
           "world"
         end
@@ -93,15 +99,17 @@ class TestToki < Test::Unit::TestCase
   end
 
   def test_maglev_version
-    unless (maglev_version_defined = defined?(MAGLEV_VERSION))
-      Object.const_set(:MAGLEV_VERSION, '1.1RC1')
+    if (maglev_version_defined = defined?(MAGLEV_VERSION))
+      version = MAGLEV_VERSION
+    else
+      Object.const_set(:MAGLEV_VERSION, (version = 'x.x.x'))
     end
     klass = Class.new do
       extend Toki
       def hello
         nil
       end
-      when_ruby :maglev_version => '1.1RC1' do
+      when_ruby :maglev_version => version do
         def hello
           "world"
         end
@@ -114,15 +122,17 @@ class TestToki < Test::Unit::TestCase
   end
 
   def test_ironruby_version
-    unless (ironruby_version_defined = defined?(IRONRUBY_VERSION))
-      Object.const_set(:IRONRUBY_VERSION, '1.1.3')
+    if (ironruby_version_defined = defined?(IRONRUBY_VERSION))
+      version = IRONRUBY_VERSION
+    else
+      Object.const_set(:IRONRUBY_VERSION, (version = 'x.x.x'))
     end
     klass = Class.new do
       extend Toki
       def hello
         nil
       end
-      when_ruby :ironruby_version => '1.1.3' do
+      when_ruby :ironruby_version => version do
         def hello
           "world"
         end
@@ -135,15 +145,17 @@ class TestToki < Test::Unit::TestCase
   end
 
   def test_kiji_version
-    unless (kiji_version_defined = defined?(KIJI_VERSION))
-      Object.const_set(:KIJI_VERSION, '0.11')
+    if (kiji_version_defined = defined?(KIJI_VERSION))
+      version = KIJI_VERSION
+    else
+      Object.const_set(:KIJI_VERSION, (version = 'x.x.x'))
     end
     klass = Class.new do
       extend Toki
       def hello
         nil
       end
-      when_ruby :kiji_version => '0.11' do
+      when_ruby :kiji_version => version do
         def hello
           "world"
         end
@@ -188,6 +200,40 @@ class TestToki < Test::Unit::TestCase
     assert_equal "world", instance.hello
   end
 
+  def test_ruby_engine_with_symbol_argument
+    ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
+    ruby_engine = ruby_engine.to_sym
+    klass = Class.new do
+      extend Toki
+      def hello
+        nil
+      end
+      when_ruby :engine => ruby_engine do
+        def hello
+          "world"
+        end
+      end
+    end
+    instance = klass.new
+    assert_equal "world", instance.hello
+  end
+
+  def test_ruby_version_with_array_argument
+    klass = Class.new do
+      extend Toki
+      def hello
+        nil
+      end
+      when_ruby :version => ['x.x.x', RUBY_VERSION] do
+        def hello
+          "world"
+        end
+      end
+    end
+    instance = klass.new
+    assert_equal "world", instance.hello
+  end
+
   def test_platform
     klass = Class.new do
       extend Toki
@@ -221,4 +267,18 @@ class TestToki < Test::Unit::TestCase
     assert_equal "world", klass.hello
   end
 
+  def test_include_toki_to_instance
+    klass = Class.new do
+      include Toki
+      def raise_exception
+        when_ruby_version RUBY_VERSION do
+          raise RuntimeError
+        end
+      end
+    end
+    assert_raises RuntimeError do
+      klass.new.raise_exception
+    end
+  end
+
 end

data/version

@@ -1 +1 @@
-0.0.2
+0.0.3

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: toki
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Jussi Koljonen
@@ -29,6 +29,7 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE
 - README.md