recurs 0.0.4.1 → 0.0.4.2

data/Gemfile

@@ -5,6 +5,6 @@ gemspec
 
 group :test do
   #gem 'rails', '3.0.1'
-  gem 'rspec'
-  gem 'aruba'
+  gem 'rspec', '~> 2.3.0'
+  gem 'aruba', '~> 0.2.7'
 end

data/Gemfile.lock

@@ -0,0 +1,51 @@
+PATH
+  remote: .
+  specs:
+    recurs (0.0.4.1)
+      actic
+      ri_cal (>= 0.8.7)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actic (0.0.2)
+      ri_cal (>= 0.8.7)
+    aruba (0.2.7)
+      background_process
+      cucumber (~> 0.10.0)
+    background_process (1.2)
+    builder (3.0.0)
+    cucumber (0.10.0)
+      builder (>= 2.1.2)
+      diff-lcs (~> 1.1.2)
+      gherkin (~> 2.3.2)
+      json (~> 1.4.6)
+      term-ansicolor (~> 1.0.5)
+    diff-lcs (1.1.2)
+    gherkin (2.3.2)
+      json (~> 1.4.6)
+      term-ansicolor (~> 1.0.5)
+    json (1.4.6)
+    rake (0.8.7)
+    ri_cal (0.8.7)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.0)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+    term-ansicolor (1.0.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  actic
+  aruba (~> 0.2.7)
+  cucumber
+  rake
+  recurs!
+  ri_cal (>= 0.8.7)
+  rspec (~> 2.3.0)

data/features/generators.feature

@@ -12,16 +12,21 @@ Feature:
     source "http://rubygems.org"
     gem 'rails', '3.0.0'
     gem 'sqlite3-ruby', :require => 'sqlite3'
-    gem 'recurs', :path => '../../../'
+    gem 'recurs' #, :path => '../../../'
     """
     And I run "bundle install"
     And I run "rails generate recurs_widget Event"
-    And I run "rake db:migrate"
+    Then the output should contain:
+      """
+        create  app/models/event.rb
+
+      """
     And the following files should exist:
       | app/models/event.rb |
       | app/views/events/index.html.haml |
       | app/views/events/new.html.haml |
       | app/views/events/edit.html.haml |
       | app/views/events/_form.html.haml |
+      | app/views/events/schemes/_form.html.haml |
     And the following files should not exist:
-      | test/fixtures/users.yml |
+    And I run "rake db:migrate"

data/features/step_definitions/aruba_steps.rb

@@ -1,24 +1,277 @@
-When /^I do aruba (.*)$/ do |aruba_step|
-  begin
-    When(aruba_step)
-  rescue => e
-    @aruba_exception = e
+require 'aruba/api'
+#require 'aruba/cucumber'
+#=begin
+World(Aruba::Api)
+
+Before('@disable-bundler') do
+  unset_bundler_env_vars
+end
+
+Before do
+  @__aruba_original_paths = (ENV['PATH'] || '').split(File::PATH_SEPARATOR)
+  ENV['PATH'] = ([File.expand_path('bin')] + @__aruba_original_paths).join(File::PATH_SEPARATOR)
+end
+
+After do
+  ENV['PATH'] = @__aruba_original_paths.join(File::PATH_SEPARATOR)
+end
+
+Before do
+  FileUtils.rm_rf(current_dir)
+end
+
+Before('@puts') do
+  @puts = true
+end
+
+Before('@announce-cmd') do
+  @announce_cmd = true
+end
+
+Before('@announce-stdout') do
+  @announce_stdout = true
+end
+
+Before('@announce-stderr') do
+  @announce_stderr = true
+end
+
+Before('@announce-dir') do
+  @announce_dir = true
+end
+
+Before('@announce-env') do
+  @announce_env = true
+end
+
+Before('@announce') do
+  @announce_stdout = true
+  @announce_stderr = true
+  @announce_cmd = true
+  @announce_dir = true
+  @announce_env = true
+end
+
+After do
+  restore_env
+end
+
+Given /^I'm using a clean gemset "([^"]*)"$/ do |gemset|
+  use_clean_gemset(gemset)
+end
+
+Given /^a directory named "([^"]*)"$/ do |dir_name|
+  create_dir(dir_name)
+end
+
+Given /^a file named "([^"]*)" with:$/ do |file_name, file_content|
+  create_file(file_name, file_content)
+end
+
+Given /^an empty file named "([^"]*)"$/ do |file_name|
+  create_file(file_name, "")
+end
+
+When /^I write to "([^"]*)" with:$/ do |file_name, file_content|
+  create_file(file_name, file_content, false)
+end
+
+When /^I overwrite "([^"]*)" with:$/ do |file_name, file_content|
+  create_file(file_name, file_content, true)
+end
+
+When /^I append to "([^"]*)" with:$/ do |file_name, file_content|
+  append_to_file(file_name, file_content)
+end
+
+When /^I remove the file "([^"]*)"$/ do |file_name|
+  remove_file(file_name)
+end
+
+When /^I cd to "([^"]*)"$/ do |dir|
+  cd(dir)
+end
+
+When /^I run "(.*)"$/ do |cmd|
+  run_simple(unescape(cmd), false)
+#  sleep(5)
+end
+
+When /^I successfully run "(.*)"$/ do |cmd|
+  run_simple(unescape(cmd))
+end
+
+When /^I run "([^"]*)" interactively$/ do |cmd|
+  run_interactive(unescape(cmd))
+end
+
+When /^I type "([^"]*)"$/ do |input|
+  write_interactive(ensure_newline(input))
+end
+
+Then /^the output should contain "([^"]*)"$/ do |partial_output|
+  assert_partial_output(unescape(partial_output))
+end
+
+Then /^the output from "([^"]*)" should contain "([^"]*)"$/ do |cmd, partial_output|
+  output_from(cmd).should include(unescape(partial_output))
+end
+
+Then /^the output from "([^"]*)" should not contain "([^"]*)"$/ do |cmd, partial_output|
+  output_from(cmd).should_not include(unescape(partial_output))
+end
+
+Then /^the output should not contain "([^"]*)"$/ do |partial_output|
+  all_output.should_not include(unescape(partial_output))
+end
+
+Then /^the output should contain:$/ do |partial_output|
+  all_output.should include(unescape(partial_output))
+end
+
+Then /^the output should not contain:$/ do |partial_output|
+  all_output.should_not include(unescape(partial_output))
+end
+
+Then /^the output should contain exactly "([^"]*)"$/ do |exact_output|
+  all_output.should == unescape(exact_output)
+end
+
+Then /^the output should contain exactly:$/ do |exact_output|
+  all_output.should == unescape(exact_output)
+end
+
+# "the output should match" allows regex in the partial_output, if
+# you don't need regex, use "the output should contain" instead since
+# that way, you don't have to escape regex characters that
+# appear naturally in the output
+Then /^the output should match \/([^\/]*)\/$/ do |partial_output|
+  all_output.should =~ /#{partial_output}/
+end
+
+Then /^the output should match:$/ do |partial_output|
+  all_output.should =~ /#{partial_output}/m
+end
+
+Then /^the exit status should be (\d+)$/ do |exit_status|
+  @last_exit_status.should == exit_status.to_i
+end
+
+Then /^the exit status should not be (\d+)$/ do |exit_status|
+  @last_exit_status.should_not == exit_status.to_i
+end
+
+Then /^it should (pass|fail) with:$/ do |pass_fail, partial_output|
+  self.__send__("assert_#{pass_fail}ing_with", partial_output)
+end
+
+Then /^it should (pass|fail) with exactly:$/ do |pass_fail, exact_output|
+  assert_exit_status_and_output(pass_fail == "pass", exact_output, true)
+end
+
+Then /^it should (pass|fail) with regexp?:$/ do |pass_fail, partial_output|
+  Then "the output should match:", partial_output
+  if pass_fail == 'pass'
+    @last_exit_status.should == 0
+  else
+    @last_exit_status.should_not == 0
   end
 end
 
-# Useful for debugging timing problems
-When /^sleep (\d+)$/ do |time|
-  sleep time.to_i
+Then /^the stderr should contain "([^"]*)"$/ do |partial_output|
+  all_stderr.should include(unescape(partial_output))
+end
+
+Then /^the stderr should contain exactly:$/ do |exact_output|
+  all_stderr.should == exact_output
+end
+
+Then /^the stdout should contain "([^"]*)"$/ do |partial_output|
+  all_stdout.should include(unescape(partial_output))
+end
+
+Then /^the stdout should contain exactly:$/ do |exact_output|
+  all_stdout.should == exact_output
+end
+
+Then /^the stderr should not contain "([^"]*)"$/ do |partial_output|
+  all_stderr.should_not include(unescape(partial_output))
+end
+
+Then /^the stdout should not contain "([^"]*)"$/ do |partial_output|
+  all_stdout.should_not include(unescape(partial_output))
+end
+
+Then /^the stdout from "([^"]*)" should contain "([^"]*)"$/ do |cmd, partial_output|
+  stdout_from(cmd).should include(unescape(partial_output))
+end
+
+Then /^the stdout from "([^"]*)" should not contain "([^"]*)"$/ do |cmd, partial_output|
+  stdout_from(cmd).should_not include(unescape(partial_output))
+end
+
+Then /^the stderr from "([^"]*)" should contain "([^"]*)"$/ do |cmd, partial_output|
+  stderr_from(cmd).should include(unescape(partial_output))
+end
+
+Then /^the stderr from "([^"]*)" should not contain "([^"]*)"$/ do |cmd, partial_output|
+  stderr_from(cmd).should_not include(unescape(partial_output))
+end
+
+Then /^the file "([^"]*)" should not exist$/ do |file_name|
+  check_file_presence([file_name], false)
+end
+
+Then /^the following files should exist:$/ do |files|
+  check_file_presence(files.raw.map{|file_row| file_row[0]}, true)
+end
+
+Then /^the following files should not exist:$/ do |files|
+  check_file_presence(files.raw.map{|file_row| file_row[0]}, false)
+end
+
+Then /^a file named "([^"]*)" should exist$/ do |file|
+  check_file_presence([file], true)
+end
+
+Then /^a file named "([^"]*)" should not exist$/ do |file|
+  check_file_presence([file], false)
+end
+
+Then /^the following directories should exist:$/ do |directories|
+  check_directory_presence(directories.raw.map{|directory_row| directory_row[0]}, true)
+end
+
+Then /^the following directories should not exist:$/ do |directories|
+  check_directory_presence(directories.raw.map{|directory_row| directory_row[0]}, false)
+end
+
+Then /^a directory named "([^"]*)" should exist$/ do |directory|
+  check_directory_presence([directory], true)
+end
+
+Then /^a directory named "([^"]*)" should not exist$/ do |directory|
+  check_directory_presence([directory], false)
+end
+
+Then /^the file "([^"]*)" should contain "([^"]*)"$/ do |file, partial_content|
+  check_file_content(file, partial_content, true)
+end
+
+Then /^the file "([^"]*)" should not contain "([^"]*)"$/ do |file, partial_content|
+  check_file_content(file, partial_content, false)
+end
+
+Then /^the file "([^"]*)" should contain exactly:$/ do |file, exact_content|
+  check_exact_file_content(file, exact_content)
 end
 
-Then /^aruba should fail with "([^"]*)"$/ do |error_message|
-  @aruba_exception.message.should include(unescape(error_message))
+Then /^the file "([^"]*)" should match \/([^\/]*)\/$/ do |file, partial_content|
+  check_file_content(file, /#{partial_content}/, true)
 end
 
-Then /^the following step should fail with Spec::Expectations::ExpectationNotMetError:$/ do |multiline_step|
-  proc {steps multiline_step}.should raise_error(RSpec::Expectations::ExpectationNotMetError)
+Then /^the file "([^"]*)" should not match \/([^\/]*)\/$/ do |file, partial_content|
+  check_file_content(file, /#{partial_content}/, false)
 end
 
-Then /^the output should be (\d+) bytes long$/ do |length|
-  all_output.chomp.length.should == length.to_i
-end
+#=end

data/features/support/aruba.rb

@@ -1 +1,297 @@
-require 'aruba'
+#require 'aruba'
+require 'fileutils'
+require 'rbconfig'
+require 'aruba/process'
+
+module Aruba
+  module Api
+    def in_current_dir(&block)
+      _mkdir(current_dir)
+      Dir.chdir(current_dir, &block)
+    end
+
+    def current_dir
+      File.join(*dirs)
+    end
+
+    def cd(dir)
+      dirs << dir
+      raise "#{current_dir} is not a directory." unless File.directory?(current_dir)
+    end
+
+    def dirs
+      @dirs ||= ['tmp/aruba']
+    end
+
+    def create_file(file_name, file_content, check_presence = false)
+      in_current_dir do
+        raise "expected #{file_name} to be present" if check_presence && !File.file?(file_name)
+        _mkdir(File.dirname(file_name))
+        File.open(file_name, 'w') { |f| f << file_content }
+      end
+    end
+
+    def remove_file(file_name)
+      in_current_dir do
+        FileUtils.rm(file_name)
+      end
+    end
+
+    def append_to_file(file_name, file_content)
+      in_current_dir do
+        File.open(file_name, 'a') { |f| f << file_content }
+      end
+    end
+
+    def create_dir(dir_name)
+      in_current_dir do
+        _mkdir(dir_name)
+      end
+    end
+
+    def check_file_presence(paths, expect_presence)
+      prep_for_fs_check do
+        paths.each do |path|
+          if expect_presence
+            File.should be_file(path)
+          else
+            File.should_not be_file(path)
+          end
+        end
+      end
+    end
+
+    def check_file_content(file, partial_content, expect_match)
+      regexp = regexp(partial_content)
+      prep_for_fs_check do
+        content = IO.read(file)
+        if expect_match
+          content.should =~ regexp
+        else
+          content.should_not =~ regexp
+        end
+      end
+    end
+
+    def check_exact_file_content(file, exact_content)
+      prep_for_fs_check { IO.read(file).should == exact_content }
+    end
+
+    def check_directory_presence(paths, expect_presence)
+      prep_for_fs_check do
+        paths.each do |path|
+          if expect_presence
+            File.should be_directory(path)
+          else
+            File.should_not be_directory(path)
+          end
+        end
+      end
+    end
+
+    def prep_for_fs_check(&block)
+      stop_processes!
+      in_current_dir{ block.call }
+    end
+
+    def _mkdir(dir_name)
+      FileUtils.mkdir_p(dir_name) unless File.directory?(dir_name)
+    end
+
+    def unescape(string)
+      eval(%{"#{string}"})
+    end
+
+    def regexp(string_or_regexp)
+      Regexp === string_or_regexp ? string_or_regexp : Regexp.compile(Regexp.escape(string_or_regexp))
+    end
+
+    def output_from(cmd)
+      cmd = detect_ruby(cmd)
+      processes[cmd].output
+    end
+
+    def stdout_from(cmd)
+      cmd = detect_ruby(cmd)
+      processes[cmd].stdout
+    end
+
+    def stderr_from(cmd)
+      cmd = detect_ruby(cmd)
+      processes[cmd].stderr
+    end
+
+    def all_stdout
+      processes.values.inject("") { |out, ps| out << ps.stdout }
+    end
+
+    def all_stderr
+      processes.values.inject("") { |out, ps| out << ps.stderr }
+    end
+
+    def all_output
+      all_stdout << all_stderr
+    end
+
+    def assert_exact_output(exact_output)
+      all_output.should == exact_output
+    end
+
+    def assert_partial_output(partial_output)
+      all_output.should include(unescape(partial_output))
+    end
+
+    def assert_passing_with(partial_output)
+      assert_exit_status_and_partial_output(true, partial_output)
+    end
+
+    def assert_failing_with(partial_output)
+      assert_exit_status_and_partial_output(false, partial_output)
+    end
+
+    def assert_exit_status_and_partial_output(expect_to_pass, partial_output)
+      assert_partial_output(partial_output)
+      assert_exiting_with(expect_to_pass)
+    end
+
+    def assert_exit_status_and_output(expect_to_pass, output, expect_exact_output)
+      if expect_exact_output
+        assert_exact_output(output)
+      else
+        assert_partial_output(output)
+      end
+      assert_exiting_with(expect_to_pass)
+    end
+
+    def assert_exiting_with(expect_to_pass)
+      if expect_to_pass
+        @last_exit_status.should == 0
+      else
+        @last_exit_status.should_not == 0
+      end
+    end
+
+    def install_gems(gemfile)
+      create_file("Gemfile", gemfile)
+      if ENV['GOTGEMS'].nil?
+        run("gem install bundler")
+        run("bundle --no-color install")
+      end
+    end
+
+    def processes
+      @processes ||= {}
+    end
+
+    def stop_processes!
+      processes.each do |_, process|
+        process.stop
+      end
+    end
+
+    def run(cmd)
+      cmd = detect_ruby(cmd)
+
+      in_current_dir do
+        announce_or_puts("$ cd #{Dir.pwd}") if @announce_dir
+        announce_or_puts("$ #{cmd}") if @announce_cmd
+
+        process = processes[cmd] = Process.new(cmd, timeout)
+        process.run!
+
+        block_given? ? yield(process) : process
+      end
+    end
+
+    DEFAULT_TIMEOUT_SECONDS = 1
+
+    def timeout
+      @aruba_timeout_seconds || DEFAULT_TIMEOUT_SECONDS
+    end
+
+    def run_simple(cmd, fail_on_error=true)
+      @last_exit_status = run(cmd) do |process|
+        announce_or_puts(process.stdout) if @announce_stdout
+        announce_or_puts(process.stderr) if @announce_stderr
+        process.stop
+      end
+      @timed_out = @last_exit_status.nil?
+
+      if(@last_exit_status != 0 && fail_on_error)
+        fail("Exit status was #{@last_exit_status}. Output:\n#{all_output}")
+      end
+    end
+
+    def run_interactive(cmd)
+      @interactive = run(cmd)
+    end
+
+    def write_interactive(input)
+      @interactive.stdin.write(input)
+    end
+
+    def announce_or_puts(msg)
+      if(@puts)
+        puts(msg)
+      else
+        announce(msg)
+      end
+    end
+
+    def detect_ruby(cmd)
+      if cmd =~ /^ruby\s/
+        cmd.gsub(/^ruby\s/, "#{current_ruby} ")
+      else
+        cmd
+      end
+    end
+
+    def current_ruby
+      File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+    end
+
+    def use_clean_gemset(gemset)
+      run_simple(%{rvm gemset create "#{gemset}"}, true)
+      if all_stdout =~ /'#{gemset}' gemset created \((.*)\)\./
+        gem_home = $1
+        set_env('GEM_HOME', gem_home)
+        set_env('GEM_PATH', gem_home)
+        set_env('BUNDLE_PATH', gem_home)
+
+        paths = (ENV['PATH'] || "").split(File::PATH_SEPARATOR)
+        paths.unshift(File.join(gem_home, 'bin'))
+        set_env('PATH', paths.uniq.join(File::PATH_SEPARATOR))
+
+        run_simple("gem install bundler", true)
+      else
+        raise "I didn't understand rvm's output: #{all_stdout}"
+      end
+    end
+
+    def unset_bundler_env_vars
+      %w[RUBYOPT BUNDLE_PATH BUNDLE_BIN_PATH BUNDLE_GEMFILE].each do |key|
+        set_env(key, nil)
+      end
+    end
+
+    def set_env(key, value)
+      announce_or_puts(%{$ export #{key}="#{value}"}) if @announce_env
+      original_env[key] = ENV.delete(key)
+      ENV[key] = value
+    end
+
+    def restore_env
+      original_env.each do |key, value|
+        ENV[key] = value
+      end
+    end
+
+    def original_env
+      @original_env ||= {}
+    end
+
+    def ensure_newline(str)
+      str.chomp << "\n"
+    end
+  end
+end

data/features/support/env.rb

@@ -1,5 +1,13 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-require 'aruba/cucumber'
+require 'aruba'
+# This should only be called if the gem is vendored, otherwise it will probably attempt to write to your
+# root directory!!!
+ Before do
+    @dirs = [File.expand_path(File.dirname(__FILE__) + '/../../../../../../aruba_test_dir')]
+ end
+
+=begin
+#$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+#require 'aruba/cucumber'
 require 'fileutils'
 
 begin
@@ -12,4 +20,5 @@ end
 
 Before do
   FileUtils.rm(Dir['config/*.yml'])
-end
+end
+=end

data/lib/generators/recurs_widget_generator.rb

@@ -0,0 +1,26 @@
+module Recurs
+class WidgetGenerator < Rails::Generators::Base
+  source_root File.expand_path("../templates", __FILE__)
+  argument :name, :type => :string, :default => "event"
+
+  def create_instance_model
+    template "instance.rb.tmpl", "app/models/#{name}.rb"
+    #create_file "app/models#{model_name}"
+  end
+
+  def create_instance_views
+    ['index', 'show', 'edit', 'new', '_form'].each {|v|
+    template "views/#{v}", "app/views/#{name.downcase}/#{v}.html.haml"
+    }
+  end
+
+  def create_instance_route
+    insert_into_file 'config/routes.rb'
+  end
+
+  def create_instance_controller
+
+  end
+
+end
+end

data/lib/recurs/version.rb

@@ -1,3 +1,3 @@
 module Recurs
-  VERSION = "0.0.4.1"
+  VERSION = "0.0.4.2"
 end

data/recurs.gemspec

@@ -14,6 +14,7 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "recurs"
   s.add_dependency('ri_cal', '>= 0.8.7')
+  s.add_dependency('actic')
 
   s.add_development_dependency 'rspec', '~> 2.3.0'
   s.add_development_dependency 'aruba', '~> 0.2.7'

data/test/generator_test.rb

@@ -0,0 +1,13 @@
+class RecursWidgetGeneratorTest < Rails::Generators::TestCase
+  tests Recurs::WidgetGenerator
+  destination File.expand_path("../tmp", File.dirname(__FILE__))
+  setup :prepare_destination
+
+  test "Assert all files are properly created" do
+    arguments %w(event)
+    run_generator
+    assert_file "config/initializers/devise.rb"
+    assert_file "config/locales/devise.en.yml"
+  end
+
+end

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
   - 0
   - 0
   - 4
-  - 1
-  version: 0.0.4.1
+  - 2
+  version: 0.0.4.2
 platform: ruby
 authors: 
 - Steve Caney Martin
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-14 00:00:00 +00:00
+date: 2010-12-15 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,9 +34,22 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: actic
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -47,11 +60,11 @@ dependencies:
         - 0
         version: 2.3.0
   type: :development
-  version_requirements: *id002
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: aruba
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -62,11 +75,11 @@ dependencies:
         - 7
         version: 0.2.7
   type: :development
-  version_requirements: *id003
+  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: rake
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -75,11 +88,11 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id004
+  version_requirements: *id005
 - !ruby/object:Gem::Dependency 
   name: cucumber
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -88,7 +101,7 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id005
+  version_requirements: *id006
 description: Specifiy you're recurrence pattern in symbols and strings and get an ical format recurrence string
 email: 
 - steve@shakewell.co.uk
@@ -101,13 +114,15 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
+- Gemfile.lock
 - README
 - Rakefile
 - features/generators.feature
 - features/step_definitions/aruba_steps.rb
 - features/support/aruba.rb
 - features/support/env.rb
-- lib/generators/recurs_instance_generator.rb
+- lib/generators/recurs_widget_generator.rb
+- lib/generators/templates/controller.rb.tmpl
 - lib/generators/templates/instance.rb.tmpl
 - lib/recurs.rb
 - lib/recurs/consts.rb
@@ -119,6 +134,7 @@ files:
 - spec/models/parser_spec.rb
 - spec/models/rules_spec.rb
 - spec/spec_helper.rb
+- test/generator_test.rb
 has_rdoc: true
 homepage: http://rubygems.org/gems/recurs
 licenses: []
@@ -160,3 +176,4 @@ test_files:
 - spec/models/parser_spec.rb
 - spec/models/rules_spec.rb
 - spec/spec_helper.rb
+- test/generator_test.rb

data/lib/generators/recurs_instance_generator.rb

@@ -1,9 +0,0 @@
-class RecursInstanceGenerator < Rails::Generators::Base
-  source_root File.expand_path("../templates", __FILE__)
-  argument :name, :type => :string, :default => "event"
-
-  def create_instance_model
-    template "instance.rb.tmpl", "app/models/#{name}.rb"
-    #create_file "app/models#{model_name}"
-  end
-end