rapid-core 0.1

data/features/settings/string/validates/presence_of.feature

@@ -0,0 +1,37 @@
+Feature: string with validates_presence_of
+  
+  Background:
+    Given settings "my_settings.rb":
+    """
+    class MySettings
+      include Rapid::Settings
+      
+      setting.string :name
+      
+      validates_presence_of :name
+      
+    end
+    """
+  
+  Scenario: Non-blank value
+    When I load:
+    """
+    name: Dan
+    """
+    Then I should be good
+    And vice versa
+    
+  Scenario: nil value
+    When I load:
+    """
+    """
+    Then "name" should have a "can't be blank" error
+    And vice versa
+  
+  Scenario: blank value
+    When I load:
+    """
+    name: 
+    """
+    Then "name" should have a "can't be blank" error
+    And vice versa

data/features/settings/string/validates/size_of.feature

@@ -0,0 +1,30 @@
+Feature: string validates_size_of
+  
+  Background:
+    Given settings "my_settings.rb":
+    """
+    class MySettings
+      include Rapid::Settings
+      
+      setting.string :name
+        
+      validates_size_of :name, :minimum => 3
+      
+    end
+    """
+  
+  Scenario: Valid value
+    When I load:
+    """
+    name: Dan
+    """
+    Then I should be good
+    And vice versa
+
+  Scenario: Invalid value
+    When I load:
+    """
+    name: Me
+    """
+    Then "name" should have a "is too short (minimum is 3 characters)" error
+    And vice versa

data/features/step_definitions/settings_steps.rb

@@ -0,0 +1,92 @@
+After do
+  @ruby_classnames.each do |ruby_classname|
+    Object.send(:remove_const, ruby_classname.to_sym) rescue nil
+  end
+  @ruby_classnames = nil
+  
+  @settingss = nil
+  
+  @current_settings_class = nil
+end
+
+def find_settings_class filename
+  if @settingss.nil?
+    raise "Could not find settings #{filename.inspect}. No settingss defined"
+  end
+  
+  settings = @settingss[filename]
+  
+  if settings.nil?
+    raise "Could not find settings #{filename.inspect}. Skeletons available: #{@settingss.keys.inspect}"
+  end
+  
+  settings
+end
+
+def create_settings_class ruby_filename, ruby_code
+  result = eval ruby_code
+  
+  ruby_classname = File.basename(ruby_filename, ".*").camelize
+  @ruby_class = ruby_classname.constantize
+  
+  @ruby_classnames ||= []
+  @ruby_classnames.push ruby_classname
+  
+  @settingss ||= {}
+  @settingss[ruby_filename] = @ruby_class
+  @current_settings_class = @ruby_class
+end
+
+Given /^settings "([^\"]*)":$/ do |ruby_filename, ruby_code|
+  create_settings_class ruby_filename, ruby_code
+end
+
+When /^I load:$/ do |yaml_content|
+  @current_yaml = yaml_content
+  @current_settings = @current_settings_class.new
+  @current_settings.settings.load_yaml yaml_content
+end
+
+Then /^I should be good$/ do
+  unless @current_settings.valid?
+    raise "You aren't good: #{@current_settings.errors.full_messages.join(', ')}"
+  end
+end
+
+Then /^"([^\"]*)" should have a "([^\"]*)" error$/ do |attribute_name, error_message|
+  if @current_settings.nil?
+    raise "You haven't loaded a settings"
+  end
+  
+  @current_settings.valid?
+  errors = @current_settings.errors[attribute_name]
+  
+  if errors.blank?
+    raise "#{attribute_name} does not have any errors"
+  end
+  
+  errors.should include(error_message)
+  
+end
+
+Then /^vice versa$/ do
+  if @current_yaml && @current_settings
+    yaml = @current_settings.settings.to_yaml
+    yaml.should == @current_yaml
+    
+  elsif @current_template
+    original_settings = @current_settings
+    
+    new_hash = @current_template.pull @current_template_content
+    new_settings = @current_settings.class.new
+    
+    new_hash.each do |key, value|
+      new_settings.settings[key] = value
+    end
+    
+    new_settings.settings.to_dot_hash.should == original_settings.settings.to_dot_hash
+    
+  else
+    raise "Not sure what I need to reverse verify"
+  end
+end

data/features/step_definitions/skeleton_steps.rb

@@ -0,0 +1,68 @@
+Given /^a skeleton with settings "([^\"]*)":$/ do |settings_filename, settings_content|
+  create_settings_class settings_filename, settings_content
+  
+  @current_yaml = settings_content
+  @current_settings = @current_settings_class.new
+  @current_skeleton = Rapid::Skeleton::Base.new @current_settings
+end
+
+# After do
+#   @ruby_classnames.each do |ruby_classname|
+#     Object.send(:remove_const, ruby_classname.to_sym) rescue nil
+#   end
+#   @ruby_classnames = nil
+#   
+#   @skeletons = nil
+#   
+#   @current_skeleton_class = nil
+# end
+# 
+# def find_skeleton_class filename
+#   if @skeletons.nil?
+#     raise "Could not find skeleton #{filename.inspect}. No skeletons defined"
+#   end
+#   
+#   skeleton = @skeletons[filename]
+#   
+#   if skeleton.nil?
+#     raise "Could not find skeleton #{filename.inspect}. Skeletons available: #{@skeletons.keys.inspect}"
+#   end
+#   
+#   skeleton
+# end
+# 
+# Given /^a skeleton "([^\"]*)":$/ do |ruby_filename, ruby_code|
+#   result = eval ruby_code
+#   
+#   ruby_classname = File.basename(ruby_filename, ".*").camelize
+#   @ruby_class = ruby_classname.constantize
+#   
+#   @ruby_classnames ||= []
+#   @ruby_classnames.push ruby_classname
+#   
+#   @skeletons ||= {}
+#   @skeletons[ruby_filename] = @ruby_class
+#   @current_skeleton_class = @ruby_class
+# end
+# 
+# Then /^vice versa$/ do
+#   if @current_yaml && @current_skeleton
+#     yaml = @current_skeleton.settings.to_yaml
+#     yaml.should == @current_yaml
+#     
+#   elsif @current_template
+#     original_skeleton = @current_skeleton
+#     
+#     new_hash = @current_template.pull @current_template_content
+#     new_skeleton = @current_skeleton.class.new
+#     
+#     new_hash.each do |key, value|
+#       new_skeleton.settings[key] = value
+#     end
+#     
+#     new_skeleton.settings.to_dot_hash.should == original_skeleton.settings.to_dot_hash
+#     
+#   else
+#     raise "Not sure what I need to reverse verify"
+#   end
+# end

data/features/step_definitions/template_steps.rb

@@ -0,0 +1,39 @@
+After do
+  @current_template = nil
+end
+
+def find_template filename
+  if @templates.nil?
+    raise "Could not find template #{filename.inspect}. No templates defined"
+  end
+  
+  template = @templates[filename]
+  
+  if template.nil?
+    raise "Could not find template #{filename.inspect}. Templates available: #{@templates.keys.inspect}"
+  end
+  
+  template
+end
+
+
+Given /^a template "([^\"]*)":$/ do |template_filename, template_content|
+  @current_template = Rapid::Template::Base.new template_content, :filename => template_filename
+  
+  @templates ||= {}
+  @templates[template_filename] = @current_template
+end
+
+When /^I push the skeleton through "([^\"]*)" with:$/ do |template_filename, settings_content|
+  @current_template = find_template template_filename
+  
+  @current_yaml = settings_content
+  @current_skeleton.load_yaml settings_content
+  
+  @current_template_content = @current_template.push @current_skeleton
+end
+
+Then /^I should get:$/ do |content|
+  @current_template_content.should == content
+end
+

data/features/support/env.rb

@@ -0,0 +1,6 @@
+require 'rspec'
+RSpec.configure do |config|
+  config.mock_with :rspec
+end
+
+require 'rapid/core'

data/features/templates/comment_if.feature

@@ -0,0 +1,55 @@
+Feature: template with a comment_if function call
+  
+  Background:
+    Given a skeleton with settings "my_settings.rb":
+    """
+    class MySettings
+      include Rapid::Settings
+      
+      setting.boolean :foo
+      
+    end
+    """
+    And a template "static.erb":
+    """
+    class Foo < ActiveRecord::Base
+      
+      def inspect
+        <%= comment_if foo %>"foo"
+      end
+      
+    end
+    """
+  
+  Scenario: comment
+    When I push the skeleton through "static.erb" with:
+    """
+    foo: true
+    """
+    Then I should get:
+    """
+    class Foo < ActiveRecord::Base
+      
+      def inspect
+        # "foo"
+      end
+      
+    end
+    """
+    # And vice versa
+  
+  Scenario: no comment
+    When I push the skeleton through "static.erb" with:
+    """
+    """
+    Then I should get:
+    """
+    class Foo < ActiveRecord::Base
+      
+      def inspect
+        "foo"
+      end
+      
+    end
+    """
+    # And vice versa

data/features/templates/comment_unless.feature

@@ -0,0 +1,56 @@
+Feature: template with a comment_unless function call
+  
+  Background:
+    Given a skeleton with settings "my_settings.rb":
+    """
+    class MySettings
+      include Rapid::Settings
+      
+      setting.boolean :foo
+      
+    end
+    """
+    And a template "static.erb":
+    """
+    class Foo < ActiveRecord::Base
+      
+      def inspect
+        <%= comment_unless foo %>"foo"
+      end
+      
+    end
+    """
+  
+  Scenario: comment
+    When I push the skeleton through "static.erb" with:
+    """
+    foo: true
+    """
+    Then I should get:
+    """
+    class Foo < ActiveRecord::Base
+      
+      def inspect
+        "foo"
+      end
+      
+    end
+    """
+    # And vice versa
+  
+  Scenario: no comment
+    When I push the skeleton through "static.erb" with:
+    """
+    """
+    Then I should get:
+    """
+    class Foo < ActiveRecord::Base
+      
+      def inspect
+        # "foo"
+      end
+      
+    end
+    """
+    # And vice versa
+    

data/features/templates/for/for.feature

@@ -0,0 +1,51 @@
+# @wip
+# Feature: push and pull a template with a for loop
+#   
+#   Background:
+#     Given a skeleton with settings "my_settings.rb":
+#     """
+#     class MySettings
+#       include Rapid::Settings
+#       
+#       def items
+#         %w(far bar baz)
+#       end
+#       
+#     end
+#     """
+#     And a template "static.erb":
+#     """
+#     class Foo < ActiveRecord::Base
+#       
+#     <% for item in items -%>
+#       def <%= item %>
+#         "<%= item %>"
+#       end
+#     <% end -%>
+#       
+#     end
+#     """
+#   
+#   Scenario: Push and Pull Template
+#     When I push the skeleton through "static.erb" with:
+#     """
+#     """
+#     Then I should get:
+#     """
+#     class Foo < ActiveRecord::Base
+#       
+#       def foo
+#         "foo"
+#       end
+#       
+#       def bar
+#         "bar"
+#       end
+#       
+#       def baz
+#         "baz"
+#       end
+#       
+#     end
+#     """
+#     And vice versa

data/features/templates/if/else.feature

@@ -0,0 +1,60 @@
+Feature: template with an if-else statement
+  
+  Background:
+    Given a template "if.erb":
+    """
+    class Foo < ActiveRecord::Base
+      
+      def inspect
+      <% if has_inspect %>
+        "foo"
+      <% else %>
+        raise "Not implemented"
+      <% end %>
+      end
+      
+    end
+    """
+    And a skeleton with settings "my_settings.rb":
+    """
+    class MySettings
+      include Rapid::Settings
+      
+      setting.boolean :has_inspect
+      
+    end
+    """
+  
+  Scenario: true
+    When I push the skeleton through "if.erb" with:
+    """
+    has_inspect: true
+    """
+    Then I should get:
+    """
+    class Foo < ActiveRecord::Base
+      
+      def inspect
+        "foo"
+      end
+      
+    end
+    """
+    And vice versa
+  
+  Scenario: false
+    When I push the skeleton through "if.erb" with:
+    """
+    has_inspect: false
+    """
+    Then I should get:
+    """
+    class Foo < ActiveRecord::Base
+      
+      def inspect
+        raise "Not implemented"
+      end
+      
+    end
+    """
+    And vice versa

data/features/templates/if/elsif.feature

@@ -0,0 +1,82 @@
+Feature: template with an if-elsif-else statement
+  
+  Background:
+    Given a template "if.erb":
+    """
+    class Foo < ActiveRecord::Base
+      
+      def inspect
+      <% if has_inspect %>
+        "foo"
+      <% elsif raise %>
+        raise "Not implemented"
+      <% else %>
+        
+      <% end %>
+      end
+      
+    end
+    """
+    And a skeleton with settings "my_settings.rb":
+    """
+    class MySettings
+      include Rapid::Settings
+      
+      setting.boolean :has_inspect
+      setting.boolean :raise
+      
+    end
+    """
+  
+  Scenario: if
+    When I push the skeleton through "if.erb" with:
+    """
+    has_inspect: true
+    """
+    Then I should get:
+    """
+    class Foo < ActiveRecord::Base
+      
+      def inspect
+        "foo"
+      end
+      
+    end
+    """
+    And vice versa
+  
+  Scenario: elsif
+    When I push the skeleton through "if.erb" with:
+    """
+    raise: true
+    has_inspect: false
+    """
+    Then I should get:
+    """
+    class Foo < ActiveRecord::Base
+      
+      def inspect
+        raise "Not implemented"
+      end
+      
+    end
+    """
+    And vice versa
+
+  Scenario: else
+    When I push the skeleton through "if.erb" with:
+    """
+    raise: false
+    has_inspect: false
+    """
+    Then I should get:
+    """
+    class Foo < ActiveRecord::Base
+      
+      def inspect
+        
+      end
+      
+    end
+    """
+    And vice versa

data/features/templates/if/if.feature

@@ -0,0 +1,55 @@
+Feature: template with an if statement
+  
+  Background:
+    Given a template "if.erb":
+    """
+    class Foo < ActiveRecord::Base
+      
+    <% if has_inspect? %>
+      def inspect
+        "foo"
+      end
+    <% end %>
+      
+    end
+    """
+    And a skeleton with settings "my_settings.rb":
+    """
+    class MySettings
+      include Rapid::Settings
+      
+      setting.boolean :has_inspect
+      
+    end
+    """
+  
+  Scenario: true
+    When I push the skeleton through "if.erb" with:
+    """
+    has_inspect: true
+    """
+    Then I should get:
+    """
+    class Foo < ActiveRecord::Base
+      
+      def inspect
+        "foo"
+      end
+      
+    end
+    """
+    And vice versa
+  
+  Scenario: false
+    When I push the skeleton through "if.erb" with:
+    """
+    has_inspect: false
+    """
+    Then I should get:
+    """
+    class Foo < ActiveRecord::Base
+      
+      
+    end
+    """
+    And vice versa

data/features/templates/namespaces/exist.feature

@@ -0,0 +1,54 @@
+Feature: does a namespace exist
+  
+  Background:
+    Given a skeleton with settings "my_settings.rb":
+    """
+    class MySettings
+      include Rapid::Settings
+      
+      setting.string  'app.author.name'
+      
+    end
+    """
+    And a template "variables.erb":
+    """
+    class App < ActiveRecord::Base
+      
+    <% if app.author? %>
+      def author_name
+        "<%= app.author.name %>"
+      end
+    <% end %>
+      
+    end
+    """
+  
+  Scenario: does not exist
+    When I push the skeleton through "variables.erb" with:
+    """
+    """
+    Then I should get:
+    """
+    class App < ActiveRecord::Base
+      
+      
+    end
+    """
+    And vice versa
+  
+  Scenario: exists
+    When I push the skeleton through "variables.erb" with:
+    """
+    app.author.name: Dan
+    """
+    Then I should get:
+    """
+    class App < ActiveRecord::Base
+      
+      def author_name
+        "Dan"
+      end
+      
+    end
+    """
+    And vice versa