netzke-core 0.5.5 → 0.6.0

data/.autotest

@@ -1 +1 @@
-require 'autotest/redgreen'
+# require 'autotest/redgreen'

data/.gitignore

@@ -4,5 +4,7 @@ doc
 Manifest
 .DS_Store
 rdoc
-netzke-core.gemspec
-*.tmproj
+test/rails_app/tmp/
+test/rails_app/public/extjs
+test/rails_app/public/images/icons
+*.gem

data/CHANGELOG.rdoc

@@ -1,10 +1,32 @@
-= v0.5.5 - 2010-09-08
-* Merge with pschyska/netzke-core - relative_root_url, jsmin
-* Detecting actions in config now works on any level
-
-= v0.5.4 - 2010-08-11
-* New: added Netzke.pre name space for pre-built static JS code
-
+= v0.6.0 - 2010-10-24
+* Rails3 compatibility, thorough rewrite
+* Much more thorough testing
+
+* API backward incompatibility
+  * +ext_config+ config level is removed; put all that configuration in the top level
+  * mentioning actions in the +bbar+, +tbar+, etc, should be explicit, e.g.:
+  
+      :bbar => [:apply.action, :delete.action]
+      
+  * +late_aggregatee+ is now +lazy_loading+
+  * +aggregatees+ are now +components+
+  * +widgets+ are now +components+, too
+  * +api+ is now +endpoint+
+  * +persistent_config_enabled?+ is now +persistence_enabled?+
+  * Using the +js_extend_properties+ class method in your components in deprecated (and maybe even broken). Use +js_property+ (or +js_properties+) and +js_method+ instead (see multiple examples in test/rails_app)
+  * the +load_component_with_cache+ endpoint renamed to +deliver_component+
+
+* New
+  * +ext+ helper in the views to embed any (pure) Ext component into a view
+  * +component+ DSL method to declare child components
+  * +config+ DSL method to set the configuration of an instance
+  * +action+ DSL method to configure actions
+  * +js_method+ DSL method to define (public) methods in JS class
+  * +js_property+ DSL method to define (public) properties in JS class
+  * +endpoint+ DSL method to define server endpoints
+  
+* Different deprecations throughout the code
+  
 = v0.5.3 - 2010-06-14
 * Fix: Getting rid of deprecation warnings about tasks not sitting in lib.
 
@@ -47,7 +69,7 @@
 * Code: lightly better test coverage
 * New: <tt>Netzke::Base#global_id_by_reference</tt> method
 * Compatibility: resolving conflicts with the <tt>api</tt> property in some Ext v3.0 components
-* Fix: <tt>load_aggregatee_with_cache</tt> was throwing exception when the requested aggregatee wasn't defined
+* Fix: <tt>deliver_component</tt> was throwing exception when the requested component wasn't defined
 * New: <tt>persistent_config_id</tt> configuration option allows specifying an id by which persistent configuration is identified for the widget. Handy if different homogeneous widgets need to share the same persistent configuration.
 * New: <tt>Netzke::Base#persistent_config</tt> method now accepts an optional boolean parameter signalizing that the configuration is global (not bound to a widget)
 * Impr: cleaner handling of actions and toolbars; fbar configuration introduced.
@@ -60,10 +82,10 @@
 * Internal: the JavaScript instance now knows if persistent config is enabled (by checking this.persistentConfig).
 * Fix: solving the "Node cannot be inserted at the specified point in the hierarchy" problem by being more strict with duplicated IDs for elements on the same page.
 * Fix: Ext 3.0 compatibility.
-* Impr: <tt>getChildWidget</tt> now allows referring to a widget like this: "parent__parent__some_widget__some_nested_widget"
+* Impr: <tt>getChildComponent</tt> now allows referring to a widget like this: "parent__parent__some_widget__some_nested_widget"
 
 = v0.4.3
-* Fix: reworking loadAggregatee()-related code, closing a security flaw when a malicious browser could send any configuration options to instantiate the widget being loaded.
+* Fix: reworking loadComponent()-related code, closing a security flaw when a malicious browser could send any configuration options to instantiate the widget being loaded.
 
 = v0.4.2 - 2009-09-11
 * Fix: the API call (at the JavaScript side) was ignoring the callback parameter.
@@ -95,7 +117,7 @@
 * New: widgets now can check session[:netzke_just_logged_in] and session[:netzke_just_logged_out] automatically set by Netzke after login/logout
 
 = v0.2.11
-* Introduction of getOwnerWidget()-method to Ext.Component. It provides the Netzke widget this Component belongs to.
+* Introduction of getOwnerComponent()-method to Ext.Component. It provides the Netzke widget this Component belongs to.
 
 = v0.2.10
 * Removed dependency on 'json' gem.
@@ -117,11 +139,11 @@
 = v0.2.6
 * FeedackGhost is now capable of displaying multiple flash messages.
 * Dependencies slightly refactored.
-* An informative exception added to Base#aggregatee_instance.
+* An informative exception added to Base#component_instance.
 * JS-level inheritance enabled.
-* Work-around for the problem with Ext 2.2.1 in loadWidget.
+* Work-around for the problem with Ext 2.2.1 in loadComponent.
 * Events "<action_id>click" added to the widgets along with the actions.
-* aggregatee_missing method added to Netzke::Base - called when a non-existing aggregate of a widget is tried to be invoked
+* component_missing method added to Netzke::Base - called when a non-existing aggregate of a widget is tried to be invoked
 * Code readability improvements.
 
 = v0.2.5
@@ -132,7 +154,7 @@
 
 = v0.2.3
 * FeedbackGhost will show the feedback on the top of the screen independent of the page scrolling.
-* Ext.Panel#loadWidget will accept null as url to delete the currently loaded widget
+* Ext.Panel#loadComponent will accept null as url to delete the currently loaded widget
 * Bug fix: persistent_config works again
 
 = v0.2.2

data/README.rdoc

@@ -1,60 +1,125 @@
 = netzke-core
-Create Ext JS + Rails reusable components (widgets) with minimum effort.
 
-This is the bare bones of the Netzke framework. Use it to build your own widgets from scratch. For pre-built widgets (like panels, grids, forms, trees, applications), see the netzke-basepack (http://github.com/skozlov/netzke-basepack) project.
+Create Ext JS + Rails components with minimum effort.
 
-The idea behind the Netzke framework is that it allows you write reusable client/server code. Create a widget, and then embed it (or load it dynamically) into your Ext-based applications or HTML pages. For more info, see the links below.
+This is the bare bones of the Netzke framework. Use it to build your own components from scratch. For pre-built components (like panels, grids, forms, trees, applications), see the netzke-basepack (http://github.com/skozlov/netzke-basepack) project.
 
-== Instalation
-For the latest ("edge") stuff, install as plugin (recommended!):
+The idea behind the Netzke framework is that it allows you write reusable client/server code. Create a component, and then embed it straight to your Rails' view, load it dynamically into your Ext-based applications, or use it as a building block for other (composite) components. For more info, see the links below.
 
-    ./script/plugin install git://github.com/skozlov/netzke-core.git
+== Requirements
 
-Otherwise, install as gem:
+* Rails >= 3.0.0
+* Ruby >= 1.9.2 (1.8.7 should work, but may not be supported as diligently)
+* Ext >= 3.3.0
 
-    gem install netzke-core
-    
-To generate the migrations for Netzke persistent storage (if you want to use it):
+== Installation
+
+For the latest ("edge") stuff, tell bundler to get the gem straight from github:
 
-    ./script/generate netzke_core
+    gem 'netzke-core', :git => "git://github.com/skozlov/netzke-core.git"
 
-Netzke assumes that your ExtJS library is in public/extjs (which may be a symbolic link).
+Or install as plugin:
+
+    rails plugin install git://github.com/skozlov/netzke-core.git
+    
+Netzke assumes that your ExtJS library is in public/extjs (which may be a symbolic link):
+
+    ln -s ~/code/sencha/ext-3.3.0 public/extjs
 
 == Usage
-Here's how to embed a Netzke widget into your Rails view.
 
-1. In your layout, within the "head" tag, use the <tt>netzke_init</tt> helper to include all the necessary JavaScript and styles. 
+Let's create a simple "Hello world!" component and embed it into a Rails' view. It'll be an Ext.Panel-based component with a button that triggers a client-server communication.
+
+Create YOUR_APP/app/components/hello_world_component.rb, and put in the following content:
+
+    class HelloWorldComponent < Netzke::Base
+      # Ext.Panel's config option "title"
+      js_property :title, "My Hello World Component"
+
+      # Bottom bar with an automatically created action
+      js_property :bbar, [:bug_server.action]
+
+      # Method in the JS class that (by default) processes the action's "click" event
+      js_method :on_bug_server, <<-JS
+        function(){
+          // Remotely calling the server's method greet_the_world (defined below)
+          this.greetTheWorld();
+        }
+      JS
+
+      # Server's method that gets called from the JS
+      endpoint :greet_the_world do |params|
+        # Tell the client side to call its method showGreeting with "Hello World!" as parameter
+        {:show_greeting => "Hello World!"}
+      end
+
+      # Another method in the JS class that gets remotely called by the server side
+      js_method :show_greeting, <<-JS
+        function(greeting){
+          this.body.update("Server says: " + greeting);
+        }
+      JS
+    end
+
+
+To embed a Netzke component into your Rails view do the following:
+
+1. In your layout, within the "head" tag, use the <tt>netzke_init</tt> helper to include all the necessary JavaScript and styles.
 
     <%= netzke_init %>
-    
-2. In config/routes.rb declare the Netzke routes:
 
-    map.netzke
+You can optionally specify an Ext theme:
+
+    <%= netzke_init :ext_theme => 'grey' %>
+      
+2. In your view use the <tt>netzke</tt> helper to embed the component:
+
+    <%= netzke :hello_world_component %>
+
+That's it. While playing with the component, use Firebug or similar tool to check the AJAX requests to understand better what's going on behind the scenes. Also check the source code of the page embedding the component.
+
+== Running tests
+
+netzke-core is bundled with cucumber and RSpec tests. Before you can run them, you must link your Ext JS library to test/rails_app/public, e.g. (from plugin's root):
+
+    ln -s ~/code/sencha/ext-3.3.0 test/rails_app/public/extjs
+
+For cucumber tests:
+
+    cucumber features
     
-3. In your view use the <tt>netzke</tt> helper wherever you want to insert a widget.
+RSpec tests:
 
-    <%= netzke :grid_panel, :model => "User", :columns => [:id, :name, :created_at] %>
+    rspec spec
     
-(here we use the GridPanel widget from the netzke-basepack project)
+== Testing playground
+
+The bundled test/rails_app application is also a convenient playground to learn more about the framework, as it may be run as a stand-alone Rails app. It's also a pretty good source of examples. After starting it, access any of the app/components/netzke test components by using the following url:
+
+    http://localhost:3000/components/<name of the component's class>
 
-== Running in production
+e.g.:
+  
+    http://localhost:3000/components/ServerCaller
 
-1. There is some basic JS minification when running in production. This uses JSMin to strip comments, whitespace etc.
+or, for scoped components:
 
-It can also manually configured by setting :minify_js
+    http://localhost:3000/components/ScopedComponents::SomeScopedComponent
 
-Netzke::Base.configure :minify_js=>true
+== Migrating from 0.5.x
+
+There have been a significant amount of changes that made 0.6 version backward-incompatible. Please, refer to CHANGELOG.rdoc for the (hopefully) full list of changes that most certainly would make your current application break. Additionally, this wiki page may be of some help, too: http://github.com/skozlov/netzke-core/wiki/Upgrading-from-0.5.x-to-0.6.0
 
 == More info
-Introduction to Netzke framework and wiki: http://github.com/skozlov/netzke
+Netzke website: http://netzke.org
 
-Twitter: http://twitter.com/skozlov
+Live-demo with sample code: http://demo.netzke.org
 
 Tutorials: http://blog.writelesscode.com
 
-Live-demo with sample code: http://netzke-demo.writelesscode.com
+Twitter: http://twitter.com/skozlov
 
-The netzke-basepack project (pre-built full-featured widgets): http://github.com/skozlov/netzke-basepack
+The netzke-basepack project (pre-built full-featured components): http://github.com/skozlov/netzke-basepack
 
 ---
 

data/Rakefile

@@ -1,31 +1,29 @@
 begin
   require 'jeweler'
+  require './lib/netzke/core/version'
   Jeweler::Tasks.new do |gemspec|
-    gemspec.version = "0.5.5"
+    gemspec.version = Netzke::Core::Version::STRING
     gemspec.name = "netzke-core"
-    gemspec.summary = "Build ExtJS/Rails widgets with minimum effort"
+    gemspec.summary = "Build ExtJS/Rails components with minimum effort"
     gemspec.description = "Allows building ExtJS/Rails reusable code in a DRY way"
     gemspec.email = "sergei@playcode.nl"
     gemspec.homepage = "http://github.com/skozlov/netzke-core"
     gemspec.rubyforge_project = "netzke-core"
     gemspec.authors = ["Sergei Kozlov"]
-    gemspec.add_dependency("jsmin", ">=1.0.1")    
+    gemspec.add_dependency("activesupport", ">=3.0.1")
     gemspec.post_install_message = <<-MESSAGE
 
 ========================================================================
 
            Thanks for installing Netzke Core!
            
-  Don't forget to run "./script/generate netzke_core" for each Rails 
-  app that will be using this gem.
-
   Netzke home page:     http://netzke.org
   Netzke Google Groups: http://groups.google.com/group/netzke
   Netzke tutorials:     http://blog.writelesscode.com
 
 ========================================================================
 
-    MESSAGE
+MESSAGE
     
   end
   Jeweler::GemcutterTasks.new

data/TODO

@@ -1,3 +1,24 @@
-* Re-factor JS-level inheritance mechanisms (2009-07-5 why?)
-* Get rid of the default_config method, because the same functionality maybe achieved by overwriting the initialize method
-* late aggregatees should probably be named lazy aggregatees
+Make plugin-wide javascripts and stylesheets load automatically.
+Caching - investigate reusing (fragment?) caching of Rails.
+Use Ext.Direct in the Netzke controller.
+Let specify per API point if it will use a GET or a POST request.
+Re-work generators
+
+Some day
+* make gzipping generated JS code possible
+
+
+= Ideas that didn't work out
+
+== Making value from super-class accessible in the block parameters in endpoints, e.g.:
+
+    endpoint :call_server do |params, orig|
+      orig.merge(:set_title => orig[:set_title] + " extended")
+    end
+  
+Bad idea because calling the super method is often required AFTER doing something in the override, not BEFORE. For example, deliver_component in GridPanel in Basepack is overridden to reconfigure the components on the fly before actually delivering the component (i.e. calling super).
+So, to override an endpoint, simply define a method with endpoint's name, e.g.:
+
+    def call_server(params)
+      super.merge(...)
+    end

data/app/controllers/netzke_controller.rb

@@ -0,0 +1,70 @@
+class NetzkeController < ApplicationController
+  
+  # Collect javascripts and stylesheets from all plugins that registered it in Netzke::Core.javascripts
+  # TODO: caching
+  # caches_action :netzke
+  def netzke
+    respond_to do |format|
+      format.js {
+        res = initial_dynamic_javascript << "\n"
+        Netzke::Core.javascripts.each do |path|
+          f = File.new(path)
+          res << f.read
+        end
+        
+        # If JS classes are not inserted into the main page, we need to render all the classes needed to load the page that includes us
+        # (i.e. netzke/netzke.js) here
+        if !Netzke::Core.javascript_on_main_page
+          rendered_classes = []
+          Netzke::Core.session[:netzke_components].each_pair do |k,v|
+            component = Netzke::Base.instance_by_config(v)
+            res << component.js_missing_code(rendered_classes.map(&:name))
+            rendered_classes += component.dependency_classes
+            rendered_classes.uniq!
+          end
+        end
+
+        render :text => defined?(::Rails) && ::Rails.env.production? ? res.strip_js_comments : res
+      }
+      
+      format.css {
+        res = ""
+        Netzke::Core.stylesheets.each do |path|
+          f = File.new(path)
+          res << f.read
+        end
+        render :text => res
+      }
+    end
+  end
+  
+  # Main dispatcher of the HTTP requests. The URL contains the name of the component, 
+  # as well as the method of this component to be called, according to the double underscore notation. 
+  # E.g.: some_grid__post_grid_data.
+  def method_missing(method_name)
+    component_name, *action = method_name.to_s.split('__')
+    component_name = component_name.to_sym
+    action = !action.empty? && action.join("__").to_sym
+  
+    if action
+      w_instance = Netzke::Base.instance_by_config(Netzke::Core.session[:netzke_components][component_name])
+      # only component's actions starting with "endpoint_" are accessible from outside (security)
+      endpoint_action = action.to_s.index('__') ? action : "endpoint_#{action}"
+      render :text => w_instance.send(endpoint_action, params), :layout => false
+    else
+      super
+    end
+  end
+  
+  private
+    # Generates initial javascript code that is dependent on Rails environement
+    def initial_dynamic_javascript
+      res = []
+      res << %(Ext.Ajax.extraParams = {authenticity_token: '#{form_authenticity_token}'}; // Rails' forgery protection)
+      res << %{Ext.ns('Netzke');}
+      res << %{Netzke.RelativeUrlRoot = '#{ActionController::Base.config.relative_url_root}';}
+      res << %{Netzke.RelativeExtUrl = '#{ActionController::Base.config.relative_url_root}/extjs';}
+      res.join("\n")
+    end
+  
+end

data/app/models/netzke_preference.rb

@@ -0,0 +1,170 @@
+class NetzkePreference < ActiveRecord::Base
+  serialize :value
+  
+  # belongs_to :user
+  # belongs_to :role
+  
+  # ELEMENTARY_CONVERTION_METHODS= {'Fixnum' => 'to_i', 'String' => 'to_s', 'Float' => 'to_f', 'Symbol' => 'to_sym'}
+  
+  # def self.component_name=(value)
+  #   @@component_name = value
+  # end
+  # 
+  # def self.component_name
+  #   @@component_name ||= nil
+  # end
+  
+  # def normalized_value
+  #   klass      = read_attribute(:pref_type)
+  #   norm_value = read_attribute(:value)
+  #   
+  #   case klass
+  #   when nil             then r = norm_value  # do not cast
+  #   when 'Boolean'       then r = norm_value == 'false' ? false : (norm_value == 'true' || norm_value)
+  #   when 'NilClass'      then r = nil
+  #   when 'Array', 'Hash' then r = ActiveSupport::JSON.decode(norm_value)
+  #   else
+  #     r = norm_value.send(ELEMENTARY_CONVERTION_METHODS[klass])
+  #   end
+  #   r
+  # end
+  # 
+  # def normalized_value=(new_value)
+  #   case new_value.class.name
+  #   when "Array" then write_attribute(:value, new_value.to_json)
+  #   when "Hash"  then write_attribute(:value, new_value.to_json)
+  #   else              write_attribute(:value, new_value.to_s)
+  #   end
+  #   write_attribute(:pref_type, [TrueClass, FalseClass].include?(new_value.class) ? 'Boolean' : new_value.class.to_s)
+  # end
+  # 
+  # def self.[](pref_name)
+  #   pref_name  = normalize_preference_name(pref_name)
+  #   pref       = self.pref_to_read(pref_name)
+  #   pref && pref.normalized_value
+  # end
+  # 
+  # def self.[]=(pref_name, new_value)
+  #   pref_name  = normalize_preference_name(pref_name)
+  #   pref       = self.pref_to_write(pref_name)
+  #   
+  #   # if assigning nil, simply delete the eventually found preference
+  #   if new_value.nil?
+  #     pref && pref.destroy
+  #   else
+  #     # pref ||= self.new(conditions(pref_name))
+  #     pref.normalized_value = new_value
+  #     pref.save!
+  #   end
+  # end
+
+  
+
+  # Overwrite pref_to_read, pref_to_write methods, and find_all_for_component if you want a different way of 
+  # identifying the proper preference based on your own authorization strategy.
+  #
+  # The default strategy is:
+  #   1) if no masq_user or masq_role defined
+  #     pref_to_read will search for the preference for user first, then for user's role
+  #     pref_to_write will always find or create a preference for the current user (never for its role)
+  #   2) if masq_user or masq_role is defined
+  #     pref_to_read and pref_to_write will always take the masquerade into account, e.g. reads/writes will go to
+  #     the user/role specified
+  #   
+  def self.pref_to_read(name)
+    name = name.to_s
+    session = Netzke::Core.session
+    cond = {:key => name}
+    
+    if session[:masq_user]
+      # first, get the prefs for this user it they exist
+      res = self.where(cond.merge({:user_id => session[:masq_user]})).first
+
+      # if it doesn't exist, get them for the user's role
+      user = User.where(session[:masq_user])
+      res ||= self.where(cond.merge({:role_id => user.role.id})).first
+      
+      # if it doesn't exist either, get them for the World (role_id = 0)
+      res ||= self.where(cond.merge({:role_id => 0})).first 
+    elsif session[:masq_role]
+      # first, get the prefs for this role
+      res = self.where(cond.merge({:role_id => session[:masq_role]})).first
+      # if it doesn't exist, get them for the World (role_id = 0)
+      res ||= self.where(cond.merge({:role_id => 0})).first
+    elsif session[:netzke_user_id]
+      user = User.where(session[:netzke_user_id])
+      # first, get the prefs for this user
+      res = self.where(cond.merge({:user_id => user.id})).first
+      # if it doesn't exist, get them for the user's role
+      res ||= self.where(cond.merge({:role_id => user.role.id})).first
+      # if it doesn't exist either, get them for the World (role_id = 0)
+      res ||= self.where(cond.merge({:role_id => 0})).first
+    else
+      res = self.where(cond).first
+    end
+    
+    res      
+  end
+  
+  def self.pref_to_write(name)
+    name = name.to_s
+    session = Netzke::Core.session
+    cond = {:key => name}
+    
+    if session[:masq_user]
+      cond.merge!({:user_id => session[:masq_user]})
+      # first, try to find the preference for masq_user
+      res = self.where(cond).first
+      # if it doesn't exist, create it
+      res ||= self.new(cond)
+    elsif session[:masq_role]
+      # first, delete all the corresponding preferences for the users that have this role
+      Role.where(session[:masq_role]).users.each do |u|
+        self.delete_all(cond.merge({:user_id => u.id}))
+      end
+      cond.merge!({:role_id => session[:masq_role]})
+      res = self.where(cond).first
+      res ||= self.new(cond)
+    elsif session[:masq_world]
+      # first, delete all the corresponding preferences for all users and roles
+      self.delete_all(cond)
+      # then, create the new preference for the World (role_id = 0)
+      res = self.new(cond.merge(:role_id => 0))
+    elsif session[:netzke_user_id]
+      res = self.where(cond.merge({:user_id => session[:netzke_user_id]})).first
+      res ||= self.new(cond.merge({:user_id => session[:netzke_user_id]}))
+    else
+      res = self.where(cond).first
+      res ||= self.new(cond)
+    end
+    res
+  end
+  
+  # def self.find_all_for_component(name)
+  #   session = Netzke::Core.session
+  #   cond = {:component_name => name}
+  #   
+  #   if session[:masq_user] || session[:masq_role]
+  #     cond.merge!({:user_id => session[:masq_user], :role_id => session[:masq_role]})
+  #     res = self.where(cond).all
+  #   elsif session[:netzke_user_id]
+  #     user = User.where(session[:netzke_user_id])
+  #     res = self.where(cond.merge({:user_id => session[:netzke_user_id]})).all
+  #     res += self.where(cond.merge({:role_id => user.role.try(:id)})).all
+  #   else
+  #     res = self.where(cond).all
+  #   end
+  #   
+  #   res      
+  # end
+  
+  # def self.delete_all_for_component(name)
+  #   self.destroy(find_all_for_component(name))
+  # end
+  # 
+  # private
+  # def self.normalize_preference_name(name)
+  #   name.to_s.gsub(".", "__").gsub("/", "__")
+  # end
+  
+end

data/autotest/discover.rb

@@ -1,3 +1,2 @@
-Autotest.add_discovery do
-  "rails"
-end
+Autotest.add_discovery { "rails" }
+Autotest.add_discovery { "rspec2" }

data/features/actions.feature

@@ -0,0 +1,13 @@
+Feature: Actions
+  In order to value
+  As a role
+  I want feature
+
+@javascript
+Scenario: Pressing button should result in corresponding actions
+  When I go to the ComponentWithActions test page
+  Then I should see "Disabled action"
+  And button "Disabled action" should be disabled
+  
+  When I press "Some action"
+  Then I should see "Some action was triggered"

data/features/basic.feature

@@ -0,0 +1,7 @@
+Feature: Basic Netzke functionality
+  In order to value
+  As a role
+  I want feature
+  
+Scenario: Initial loading
+  Then Netzke should be initialized

data/features/client-server.feature

@@ -0,0 +1,15 @@
+Feature: Client/server communication
+  In order to value
+  As a role
+  I want feature
+
+@selenium
+Scenario: Ask server to set our title
+  Given I am on the ServerCaller test page
+  Then I should see "Server Caller"
+  
+  # When I execute "Ext.getCmp('server_caller').buttons.first().fireEvent('click');"
+  When I press "Call server"
+  Then I should see "All quiet here on the server"
+
+

data/features/complex_component.feature

@@ -0,0 +1,18 @@
+Feature: Complex component
+  In order to value
+  As a role
+  I want feature
+
+  @javascript
+  Scenario: Complex component must render properly
+    When I go to the KindaComplexComponent test page
+    Then I should see "Panel One"
+    And I should see "Panel Two"
+    And I should see "Server Caller"
+
+  @javascript
+  Scenario: The last tab of the complex component is a Netzke component that just works
+    Given I am on the KindaComplexComponent test page
+    When I follow "Server Caller"
+    And I press "Call server"
+    Then I should see "All quiet here on the server"

data/features/component.feature

@@ -0,0 +1,13 @@
+Feature: Testing Netzke::Base
+  In order to value
+  As a role
+  I want feature
+
+@javascript
+Scenario: A panel should render nicely
+  When I go to the SimpleComponent test page
+  Then I should see "SimpleComponent"
+  And I should see "Inner text"
+
+
+