calatrava 0.0.1

data/lib/calatrava/project.rb

@@ -0,0 +1,218 @@
+require 'mustache'
+require 'yaml'
+require 'xcoder'
+require 'xcodeproj'
+
+require 'calatrava/resources_build_phase'
+
+module Calatrava
+
+  class Project
+
+    def sh(cmd)
+      $stdout.puts cmd
+      system(cmd)
+    end
+
+    def self.here(directory)
+      @@current = Project.new(directory)
+    end
+
+    def self.current
+      @@current
+    end
+
+    attr_reader :name
+
+    def initialize(name, overrides = {})
+      @name = name
+      @slug = name.gsub(" ", "_").downcase
+      @title = @name[0..0].upcase + @name[1..-1]
+      @options = {}
+      if File.exists?(@name) && File.directory?(@name)
+        @path = File.expand_path(@name)
+        @options = YAML.load(IO.read(File.join(@name, 'calatrava.yml')))
+        @name = @options[:project_name]
+      end
+      @options.merge! overrides
+    end
+
+    def dev?
+      @options[:is_dev]
+    end
+
+    def create(template)
+      create_project(template)
+      create_directory_tree(template)
+      create_files(template)
+
+      create_android_tree(template)
+      create_ios_tree(template)
+    end
+
+    def create_project(template)
+      FileUtils.mkdir_p @name
+      File.open(File.join(@name, 'calatrava.yml'), "w+") do |f|
+        f.print({:project_name => @name}.to_yaml)
+      end
+    end
+
+    def target_item(item)
+      item.gsub("CALATRAVA_TMPL", @name)
+    end
+
+    def create_directory_tree(template)
+      template.walk_directories do |dir|
+        FileUtils.mkdir_p(File.join(@name, target_item(dir)))
+      end
+    end
+
+    def create_files(template)
+      template.walk_files do |file_info|
+        target_name = target_item(file_info[:name])
+        if File.extname(file_info[:name]) == ".calatrava"
+          File.open(File.join(@name, target_name.gsub(".calatrava", "")), "w+") do |f|
+            expanded = Mustache.render(IO.read(file_info[:path]),
+                                       :project_name => @name,
+                                       :project_slug => @slug,
+                                       :project_title => @title,
+                                       :dev? => dev?)
+            f.print(expanded)
+          end
+        else
+          FileUtils.cp(file_info[:path], File.join(@name, target_name))
+        end
+      end
+    end
+
+    def create_android_tree(template)
+      Dir.chdir(File.join(@name, "droid")) do
+        sh "android create project --name '#{@slug}' --path '#{@name}' --package com.#{@slug} --target android-10 --activity #{@title}"
+
+        Dir.walk("calatrava") do |item|
+          target_item = item.sub('calatrava', @name)
+          FileUtils.mkdir_p(target_item) if File.directory? item
+          FileUtils.cp(item, target_item) if File.file? item
+        end
+        Dir.chdir "#{@name}" do
+          Dir.chdir "src/com/#{@name}" do
+            FileUtils.mv "Title.java", "#{@title}.java"
+            FileUtils.mv "AndroidManifest.xml", "../../../AndroidManifest.xml"
+          end
+          FileUtils.mv "calatrava-build.xml", "build.xml"
+        end
+
+        FileUtils.rm_rf "calatrava"
+      end
+    end
+
+    def create_ios_project
+      Xcodeproj::Project.new.tap do |proj|
+        %w{Foundation UIKit CoreGraphics}.each { |fw| proj.add_system_framework fw }
+      end
+    end
+
+    def create_ios_project_groups(base_dir, proj, target)
+      source_files_for_target = []
+
+      walker = lambda do |item, group|
+        if item.directory?
+          group_name = item.basename
+          child_group = group.create_group group_name
+          item.each_child { |item| walker.call(item, child_group) }
+        elsif item.file?
+          file_path = item.relative_path_from(base_dir)
+          group.create_file file_path.to_s
+          source_files_for_target << Xcodeproj::Project::Object::PBXNativeTarget::SourceFileDescription.new(file_path, "", nil)
+        else
+          raise 'what is it then?!'
+        end
+      end
+      (base_dir + "src").each_child { |item| walker.call(item, proj.main_group) }
+      target.add_source_files source_files_for_target
+    end
+
+    def create_ios_folder_references(base_dir, proj, target)
+      FileUtils.mkdir_p "ios/public"
+      public_folder = proj.main_group.create_file "public"
+      public_folder.last_known_file_type = 'folder'
+      build_file = public_folder.build_files.new 
+
+      shared_phase = Xcodeproj::Project::Object::PBXResourcesBuildPhase.new(proj,nil,{})
+
+      shared_phase << build_file
+      target.build_phases << shared_phase
+
+    end
+
+    def create_ios_project_target(proj)
+      target = Xcodeproj::Project::Object::PBXNativeTarget.new(proj,
+        nil,
+        'productType' => 'com.apple.product-type.application',
+        'productName' => @name)
+
+      target.build_configurations.each do |config|
+        config.build_settings.merge!(Xcodeproj::Project::Object::XCBuildConfiguration::COMMON_BUILD_SETTINGS[:ios])
+
+        # E.g. [:ios, :release]
+        extra_settings_key = [:ios, config.name.downcase.to_sym]
+        if extra_settings = Xcodeproj::Project::Object::XCBuildConfiguration::COMMON_BUILD_SETTINGS[extra_settings_key]
+          config.build_settings.merge!(extra_settings)
+        end
+
+        config.build_settings.merge!({
+          "GCC_PREFIX_HEADER" => "src/#{@name}-Prefix.pch",
+          "OTHER_LDFLAGS" => ['-ObjC', '-all_load'],
+          "INFOPLIST_FILE" => "src/#{@name}-Info.plist",
+          "SKIP_INSTALL" => "NO",
+          "IPHONEOS_DEPLOYMENT_TARGET" => "5.0",
+        })
+        config.build_settings.delete "DSTROOT"
+        config.build_settings.delete "INSTALL_PATH"
+
+      end
+
+      calatrava_phase = Xcodeproj::Project::Object::PBXShellScriptBuildPhase.new(proj,nil,{})
+      target.build_phase_references.insert(0,calatrava_phase.uuid) # hacky manual way to get build phase inserted in the right place
+
+      calatrava_phase.name = "Build Calatrava Kernel & Shell"
+      calatrava_phase.shell_script = <<-EOS.split("\n").collect(&:strip).join("\n")
+        source ${SRCROOT}/../build_env.sh
+        bundle exec rake ios:xcode:prebuild
+      EOS
+
+      proj.targets << target
+      target
+    end
+
+    def create_ios_tree(template)
+      proj = create_ios_project
+      base_dir = Pathname.new(@name) + "ios"
+
+      target = create_ios_project_target(proj)
+      create_ios_project_groups(base_dir, proj, target)
+      create_ios_folder_references(base_dir, proj, target)
+
+      proj.save_as (base_dir + "#{@name}.xcodeproj").to_s
+    end
+
+    def modules
+      Dir[File.join(@path, 'kernel/app/*')].select { |n| File.directory? n }.collect { |n| File.basename n }
+    end
+
+    def src_paths
+      modules.collect { |m| "app/#{m}" }.join(':')
+    end
+
+    def build_ios(options = {})
+      proj = Xcode.project("ios/#{@name}.xcworkspace")
+      builder = proj.target(@name).config('Debug').builder
+      builder.clean
+      builder.sdk = options[:sdk] || :iphonesimulator
+      builder.build
+      builder.package
+    end
+
+  end
+
+end

data/lib/calatrava/resources_build_phase.rb

@@ -0,0 +1,19 @@
+require 'xcodeproj'
+
+module Xcodeproj
+  class Project
+  	module Object
+
+  	  class PBXResourcesBuildPhase < PBXBuildPhase
+  	    has_many :files
+
+  	    def initialize(*)
+  	      super
+  	      self.file_references ||= []
+  	    end
+  	    
+  	  end
+
+  	end
+  end
+end

data/lib/calatrava/tasks/apache.rb

@@ -0,0 +1,44 @@
+require 'erb'
+
+directory APACHE_LOGS_DIR
+
+if `uname -a`.chomp["amzn1"]
+  HTTPD = "httpd"
+  MODULES_PATH = "/usr/lib64/httpd/modules"
+  LOAD_LOG_MODULE = true
+elsif `uname`.chomp == "Linux"
+  HTTPD = "apache2"
+  MODULES_PATH = "/usr/lib/apache2/modules"
+  LOAD_LOG_MODULE = false
+else
+  HTTPD = "httpd"
+  MODULES_PATH = "/usr/libexec/apache2"
+  LOAD_LOG_MODULE = true
+end
+
+def httpd(command)
+  exec %Q|#{HTTPD} -d #{APACHE_DIR} -f conf/httpd.conf -e DEBUG -k #{command} -DNO_DETACH -DFOREGROUND|
+end
+
+def configure_apache
+  cp config_path("httpd.conf"), File.join(APACHE_DIR, 'conf')
+end
+
+def launch_apache
+  puts
+  puts "\t\t" + "*"*40
+  puts "\t\t" + "***   STARTING APACHE ON PORT 8888   ***"
+  puts "\t\t" + "*"*40
+  puts
+
+  httpd :start
+end
+
+def stop_apache
+  httpd :stop
+end
+
+def reload_apache
+  httpd :restart
+end
+

data/lib/calatrava/tasks/artifact.rb

@@ -0,0 +1,24 @@
+def artifact(path, env = nil)
+  artifact_dir = env.nil? ? "artifacts/" : "artifacts/#{env}/"
+  mkdir_p artifact_dir
+  cp path, artifact_dir, :preserve => true
+end
+
+def artifact_dir(source_path, name)
+  artifact_dir_path = "artifacts/#{name}/"
+  mkdir_p artifact_dir_path
+  sh "cp -R #{source_path}/* #{artifact_dir_path}"
+end
+
+def artifact_path(sub_path)
+  File.join("artifacts", sub_path)
+end
+
+namespace :artifact do
+  
+  desc "Removes all pre-existing artifacts"
+  task :clean do
+    rm_rf "artifacts/*.*"
+  end
+
+end

data/lib/calatrava/tasks/assets.rb

@@ -0,0 +1,6 @@
+def coffee(in_dir_or_file, out_dir)
+  if !Dir["#{in_dir_or_file}/**/*.coffee"].empty? || File.exists?(in_dir_or_file)
+    $stdout.puts "coffee #{in_dir_or_file} -> #{out_dir}"
+    sh "node_modules/coffee-script/bin/coffee --compile --output #{out_dir} #{in_dir_or_file}"
+  end
+end

data/lib/calatrava/tasks/automation.rb

@@ -0,0 +1,38 @@
+namespace :automation do
+  namespace :web do
+    desc "Runs cucumber tests against the web app"
+    task :features, [:file] => [:apache_for_features, :create_sim_link, :copy_steps_file, :clean_up_results_dir] do |t, args|
+      ENV['PATH'] = "#{ROOT_DIR}/web/features:#{ENV['PATH']}"
+      features_to_be_run = args[:file] ? "#{FEATURES_DIR}/#{args[:file]}" : FEATURES_DIR
+      sh "cucumber --strict --tags @all,@web --tags ~@wip #{features_to_be_run} --format html --out #{FEATURE_RESULTS_DIR}/report.html --format pretty"
+    end
+
+    desc "launch a daemon apache instance on port 8888 which will serve the features and mock the backend services"
+    task :apache_for_features => ['web:build', APACHE_LOGS_DIR] do
+      create_plist
+      configure_apache
+      `launchctl unload #{APACHE_DIR}/com.jenkins.calatrava.apache.plist`
+      `launchctl load -w #{APACHE_DIR}/com.jenkins.calatrava.apache.plist`
+      `sleep 5`
+    end
+
+    desc "create sim link for the ios step_definitions and support folder"
+    task :create_sim_link do
+      sh "rm -rf #{FEATURES_DIR}/step_definitions"
+      sh "rm -rf  #{FEATURES_DIR}/support"
+    end
+
+    desc "copy the web_steps file to web_steps.rb"
+    task :copy_steps_file do
+      sh "rm -f #{FEATURES_DIR}/*.rb"
+      sh "cp  #{FEATURES_DIR}/web_steps #{FEATURES_DIR}/web_steps.rb"
+    end
+
+    desc "delete and create the results dir"
+    task :clean_up_results_dir do
+      sh "rm -rf #{FEATURE_RESULTS_DIR}"
+      sh "mkdir #{FEATURE_RESULTS_DIR}"
+    end
+  end
+
+end

data/lib/calatrava/tasks/bootstrap.rb

@@ -0,0 +1,10 @@
+desc "Installs all required Ruby gems and Node.js packages for your new Calatrava project."
+task :bootstrap do
+  sh "bundle install"
+  sh "npm install"
+  cd "ios" do
+    sh "pod install"
+  end
+
+  Rake::Task['configure:development'].invoke
+end

data/lib/calatrava/tasks/build.rb

@@ -0,0 +1 @@
+task :build => ['web:build', 'ios:build', 'droid:build']

data/lib/calatrava/tasks/configuration.rb

@@ -0,0 +1,41 @@
+def config_for(environment)
+  YAML::load(File.open(CONFIG_YAML))[environment]
+end
+
+def evaluate_template(template_path, configuration)
+  file_path = File.join(CONFIG_RESULT_DIR, File.basename(template_path).gsub(".erb", ''))
+  puts "Config: #{File.basename(template_path)} -> #{File.basename(file_path)}"
+  result = ERB.new(IO.read(template_path)).result(binding)
+  IO.write(file_path, result)
+end
+
+def config_path(file)
+  env = ENV['CALATRAVA_ENV'] || "development"
+  puts "CALATRAVA_ENV = '#{env}'"
+  full_path = artifact_path(File.join(env, file))
+  fail "Could not find '#{file}' in environment '#{env}'" unless File.exists? full_path
+  full_path
+end
+
+def app_name
+end
+
+TEMPLATES = FileList["#{CONFIG_TEMPLATE_DIR}/*.erb"]
+
+namespace :configure do
+
+  %w{local development test automation production}.each do |environment|
+    desc "Create config files for #{environment} environment"
+    task environment.to_sym => [:clean, CONFIG_RESULT_DIR] do
+      configuration = config_for(environment)
+      TEMPLATES.each do |template|
+        evaluate_template(template, configuration)
+      end
+      artifact_dir(CONFIG_RESULT_DIR, environment)
+    end
+  end
+
+  task :clean do
+    rm_rf CONFIG_RESULT_DIR
+  end
+end

data/lib/calatrava/tasks/droid.rb

@@ -0,0 +1,83 @@
+namespace :droid do
+
+  version = "1.0"
+  droid_manifest = Calatrava::Manifest.new('droid')
+
+  html_views = droid_manifest.features.collect do |feature|
+    html_dir = "droid/#{Calatrava::Project.current.name}/assets/hybrid/views"
+    Dir["shell/pages/#{feature}/*.haml"].collect do |page|
+      pageName = File.basename(page, '.haml')
+      file "#{html_dir}/#{pageName}.html" => page do
+        HamlSupport::compile_hybrid_page feature, page, html_dir
+      end
+    end
+  end.flatten
+
+  desc "Creates html from haml using Android layout"
+  task :haml => [CONFIG[:droid][:html]] + html_views
+
+  desc "Compile droid-specific coffee to javascript"
+  task :coffee => CONFIG[:droid][:assets] do
+    coffee File.join(CONFIG[:droid][:root], "app"), CONFIG[:droid][:js]
+  end
+
+  desc "Copies required assets for droid"
+  task :shared => ["shell:scss", "shell:coffee", "kernel:coffee",
+                    CONFIG[:droid][:css], CONFIG[:droid][:imgs], CONFIG[:droid][:js],
+                    :config, CONFIG[:droid][:fonts]] do
+    cp_ne "#{BUILD_CORE_CSS_DIR}/*.css", CONFIG[:droid][:css]
+    cp_ne "#{ASSETS_IMG_DIR}/*", CONFIG[:droid][:imgs]
+    cp_ne "assets/lib/*.js", CONFIG[:droid][:js]
+
+    droid_manifest.js_files.each do |js_file|
+      sh "cp #{js_file} #{CONFIG[:droid][:js]}"
+    end
+    droid_manifest.load_file("droid/#{Calatrava::Project.current.name}/assets/hybrid", 'hybrid/scripts', :type => :text, :include_pages => false)
+
+    cp_ne "build/shell/js/**/*.js", CONFIG[:droid][:js]
+    cp_ne "build/kernel/js/*.js", CONFIG[:droid][:js]
+    cp_ne "#{ASSETS_FONTS_DIR}/*", CONFIG[:droid][:fonts]
+  end
+
+  task :app => [:shared, :haml, :coffee]
+
+  desc "Prepares config for the app"
+  task :config do
+    env_coffee = config_path("env.coffee")
+    coffee env_coffee, CONFIG[:droid][:js]
+  end
+
+  desc "Builds the complete Android app"
+  task :build => [:app, :config, :write_build_number] do
+    cd "droid/#{Calatrava::Project.current.name}" do
+      sh "ant clean debug"
+    end
+  end
+
+  desc "Update the app to show the correct build number"
+  task :write_build_number do
+    cd "droid/#{Calatrava::Project.current.name}" do
+      sh %{cat AndroidManifest.xml | sed -E "s/android:versionName=\".*\"/android:versionName=\\"#{version}\\">/g" > AndroidManifest.xml.new}
+      mv "AndroidManifest.xml.new", "AndroidManifest.xml"
+    end
+  end
+
+  desc "Publishes the built Android app as an artifact"
+  task :publish => :build do
+    artifact("droid/#{Calatrava::Project.current.name}/bin/#{Calatrava::Project.current.name}-debug.apk", ENV['CALATRAVA_ENV'])
+  end
+
+  desc "Deploy app to device/emulator"
+  task :deploy => :publish do
+    sh "adb uninstall com.#{Calatrava::Project.current.name} ; adb install -r artifacts/#{ENV['CALATRAVA_ENV']}/#{Calatrava::Project.current.name}-debug.apk"
+  end
+
+  desc "Clean droid public directory"
+  task :clean do
+    rm_rf CONFIG[:droid][:public]
+    cd "droid/#{Calatrava::Project.current.name}" do
+      sh "ant clean"
+    end
+  end
+
+end

data/lib/calatrava/tasks/haml.rb

@@ -0,0 +1,71 @@
+require 'haml'
+
+module HamlSupport
+
+  class Helper
+    
+    attr_reader :page_name
+
+    def initialize(feature = nil, page = nil)
+      @feature = feature
+      @page_name = page
+    end
+
+    def content_for(named_chunk)
+      chunk = @chunks[named_chunk]
+      (chunk && chunk.call) || ""
+    end
+
+    def layout_with(layout_name, content_blocks = {})
+      @chunks = content_blocks
+      layout_template = IO.read(File.join(SHELL_LAYOUTS_DIR, "#{layout_name}.haml"))
+      Haml::Engine.new(layout_template).render(self, {})
+    end
+
+    def render_partial(partial_name, locals = {})
+      partial_template = IO.read("#{partial_name}.haml")
+      Haml::Engine.new(partial_template).render(self, locals)
+    end
+
+    def render_page(page_name = nil, locals = {})
+      page_name = File.join(@feature, @page_name) unless page_name
+      page_template = IO.read(File.join('shell/pages', "#{page_name}.haml"))
+      Haml::Engine.new(page_template).render(self, locals)
+    end
+
+  end
+
+  class << self
+
+    def compile_hybrid_page(feature, page_path, output_path, options = {})
+      puts "haml page: #{page_path} -> #{output_path}"
+
+      options[:helper] = Helper.new(feature, File.basename(page_path, ".haml"))
+      options[:template] = "shell/layouts/single_page.haml"
+      options[:out] = File.join(output_path, File.basename(page_path, '.*') + '.html')
+
+      render_haml(options)
+    end
+
+    def compile(haml_path, html_dir, options = {})
+      puts "haml: #{haml_path} -> #{html_dir}"
+
+      options[:helper] ||= Helper.new
+      options[:template] = haml_path
+      options[:out] = File.join(html_dir, File.basename(haml_path, '.*') + '.html')
+
+      render_haml(options)
+    end
+
+    def render_haml(options)
+      html_path = options[:out]
+      template = IO.read(options[:template])
+
+      html = Haml::Engine.new(template).render(options[:helper])
+
+      html.gsub!("file:///android_asset/hybrid", "../assets") if options[:platform] == 'ios'
+      IO.write(html_path, html)
+    end
+  end
+
+end

data/lib/calatrava/tasks/ios.rb

@@ -0,0 +1,73 @@
+namespace :ios do
+
+
+  ios_manifest = Calatrava::Manifest.new('ios')
+
+  html_views = ios_manifest.features.collect do |feature|
+    html_dir = "ios/public/views"
+    Dir["shell/pages/#{feature}/*.haml"].collect do |page|
+      pageName = File.basename(page, '.haml')
+      file "#{html_dir}/#{pageName}.html" => page do
+        HamlSupport::compile_hybrid_page feature, page, html_dir, :platform => 'ios'
+      end
+    end
+  end.flatten
+
+  desc "Creates html from haml using iPhone layout"
+  task :haml => [CONFIG[:ios][:html]] + html_views
+
+  directory 'ios/public/assets'
+
+  desc "Copies required assets for ios"
+  task :shared => ["shell:scss", "shell:coffee", "kernel:coffee", 'ios/public/assets',
+                    CONFIG[:ios][:css], CONFIG[:ios][:imgs], CONFIG[:ios][:js], :config, CONFIG[:ios][:fonts]] do
+    cp_ne "#{BUILD_CORE_CSS_DIR}/*.css", CONFIG[:ios][:css]
+    cp_ne "#{ASSETS_IMG_DIR}/*", CONFIG[:ios][:imgs]
+    cp_ne "assets/lib/*.js", CONFIG[:ios][:js]
+    cp_ne "ios/res/js/*.js", CONFIG[:ios][:js]
+
+    ios_manifest.js_files.each do |js_file|
+      sh "cp #{js_file} #{CONFIG[:ios][:js]}"
+    end
+    ios_manifest.load_file('ios/public/assets', '%@/public/assets/scripts', :type => :text, :include_pages => false)
+
+    cp_ne "build/shell/js/**/*.js", CONFIG[:ios][:js]
+    cp_ne "build/kernel/js/*.js", CONFIG[:ios][:js]
+    cp_ne "#{ASSETS_FONTS_DIR}/*", CONFIG[:ios][:fonts]
+  end
+
+  task :app => [:shared, :haml]
+
+  desc "Prepares config for the app"
+  task :config do
+    env_coffee = config_path("env.coffee")
+    coffee env_coffee, CONFIG[:ios][:js]
+  end
+
+  task :configured_app => [:app, :config]
+
+  desc "Builds the iOS app"
+  task :build => :configured_app do
+    ENV['CMDLINE_BUILD'] = 'true'
+    Calatrava::Project.current.build_ios
+  end
+
+  desc "Publish the iOS app as an artifact"
+  task :publish => :build do
+    artifact(CONFIG[:ios][:xcode][:package_path], ENV['CALATRAVA_ENV'])
+  end
+
+  desc "Clean ios public directory"
+  task :clean do
+    sh "rm -rf #{CONFIG[:ios][:public]}/*"
+  end
+
+  namespace :xcode do
+    task :prebuild do
+      if !ENV['CMDLINE_BUILD']
+        Rake::Task['configure:development'].invoke
+        Rake::Task['ios:configured_app'].invoke
+      end
+    end
+  end
+end

data/lib/calatrava/tasks/kernel.rb

@@ -0,0 +1,52 @@
+namespace :kernel do
+
+  directory "build/kernel/js"
+
+  desc "Build kernel js files"
+  task :coffee => "build/kernel/js" do
+    coffee "kernel/app", "build/kernel/js"
+  end
+
+  desc "Clean built kernel"
+  task :clean do
+    rm_rf "build/kernel"
+  end
+
+  file '.node_updated' => 'package.json' do
+    sh "npm install"
+    sh "touch .node_updated"
+  end
+
+  desc "Run jasmine test. If specs not given in argument, runs all test"
+  task :spec => '.node_updated' do |t, args|
+    cd "kernel" do
+      ENV['NODE_PATH'] = "app:#{Calatrava::Project.current.src_paths}:spec:../assets/lib"
+      sh "../node_modules/jasmine-node/bin/jasmine-node --coffee --test-dir spec"
+    end
+  end
+
+  desc "Run cucumber.js features for kernel"
+  task :features, [:file] => ['.node_updated', :create_sim_link] do |t, args|
+    cd "kernel" do
+      ENV['NODE_PATH'] = "#{Calatrava::Project.current.src_paths}:features/support:../assets/lib:features/step_definitions:../features/testdata"
+      features_to_be_run = args[:file] ? "#{kernel/features}/#{args[:file]}" : "features"
+      sh "../node_modules/cucumber/bin/cucumber.js --tags @all,@kernel --tags ~@wip '#{features_to_be_run}'"
+    end
+  end
+
+  namespace :features do
+    task :wip => ['.node_updated', :create_sim_link] do
+      cd "kernel" do
+        ENV['NODE_PATH'] = "#{Calatrava::Project.current.src_paths}:features/support:../assets/lib:features/step_definitions:../features/testdata"
+        sh "../node_modules/cucumber/bin/cucumber.js --tags @wip --tags @kernel features"
+      end
+    end
+  end
+
+  desc "create sim link for the kernels step_definitions and support folder"
+  task :create_sim_link do
+    sh "ln -sFfh kernel/features/step_definitions/ features/step_definitions"
+    sh "ln -sFfh kernel/features/support/ features/support"
+  end
+
+end