sandwich 0.0.17 → 0.0.18

data/VERSION

@@ -1 +1 @@
-0.0.17
+0.0.18

data/lib/sandwich/cucumber/debug_steps.rb

@@ -18,7 +18,7 @@ Then /^show me the source for ([^\"]+)$/ do |selector|
   puts locate(selector_for(selector)).html
 end
 
-Then /^wait (\d+)$/ do |time|
+Then /^(?:|I )wait (\d+)$/ do |time|
   sleep time.to_i
 end
 

data/lib/sandwich/cucumber/ivar_steps.rb

@@ -0,0 +1,11 @@
+Given /^(?:a|the) (.+) with the following content:$/ do |selector, content|
+  instance_variable_set("@#{ivar(selector)}", content)
+end
+
+Given /^"([^\"]*)" is "([^\"]*)" in the (.+)$/ do |var, val, selector|
+  instance_variable_get("@#{ivar(selector)}").gsub!(var, val)
+end
+
+def ivar(selector)
+  selector.underscore.downcase
+end

data/lib/sandwich/cucumber/model_steps.rb

@@ -5,7 +5,14 @@ Given /^((?:an?|the|\d+) .+)$/ do |target|
   when String
     raise %Q{Could not materialize "#{target}"}
   else
-    target
+    target.tap do
+      case target
+      when Array
+        target.each(&:save!)
+      else
+        target.save!
+      end
+    end
   end
 end
 
@@ -14,7 +21,7 @@ Transform /(?:an?|\d+|the) .+/ do |match|
 end
 
 Given /^(an?|the|\d+) (.+) with the following attributes:$/ do |total, what, table|
-  total.times { record!(what, table.rows_hash) }
+  total.times { record!(what, table.rows_hash).save! }
 end
 
 Given /^(.+) belong(?:ing|s) to (an?|the) (.+)$/ do |child, determiner, rest|
@@ -24,22 +31,34 @@ Given /^(.+) belong(?:ing|s) to (an?|the) (.+)$/ do |child, determiner, rest|
   raise "No association found for #{d.raw_model}" unless a
 
   parent = materialize!("#{d.raw_determiner} #{a.class_name} #{d.raw_attributes}")
-
+  parent.save!
+  
   child.send("#{d.raw_model.underscore}=", parent)
   child.save!
 end
 
-Given /^(.+) has (.+)$/ do |parent, child|
-  case child
-  when Array
-    child.each { |c| parent.send(child.first.class.name.underscore.pluralize) << c }
+Given /^(.+) has ((no|a|the|\d+) .+)$/ do |parent, child, determiner|
+  parent.save!
+  
+  if determiner == "no"
+    d = definition(child)
+    a = parent.class.reflect_on_association(d.raw_model.underscore.to_sym)
+    
+    raise "No association found for #{d.raw_model}" unless a
+
+    parent.send(d.raw_model).delete_all
   else
-    parent.send(child.class.name.underscore.pluralize) << child
+    case child
+    when Array
+      child.each { |c| parent.send(child.first.class.name.underscore.pluralize) << c }
+    else
+      parent.send(child.class.name.underscore.pluralize) << child
+    end
   end
 end
 
 Given /^the following (.+):$/ do |what, table|
   model = what.singularize
 
-  table.hashes.each { |h| record!(model, h) }
+  table.hashes.each { |h| record!(model, h).save! }
 end

data/lib/sandwich/cucumber/web_steps.rb

@@ -12,6 +12,10 @@ When /^I follow "([^\"]*)"(?: (?:with)?in (.+))$/ do |link, container|
   inside(xpath(selector_for(container))) { click_link(link) }
 end
 
+When /^I select "([^\"]*)" from (.+?)(?: (?:with)?in (.+))?$/ do |value, field_selector, container|
+  inside(xpath(container)) { select(value, :from => selector_for(field_selector)) }
+end
+
 Then /^I should see "([^\"]*)" (?:with)?in (.+)$/ do |text, selector|
   page.should have_xpath(xpath(selector_for(selector)), :text => text)
 end

data/lib/sandwich/ext/string.rb

@@ -2,11 +2,11 @@ class String
   alias_method :super_to_i, :to_i
   alias_method :super_underscore, :underscore
 
-  def to_i
+  def to_i(*args)
     case self
     when "a", "the", "an" then 1
     when "no" then 0
-    else super_to_i
+    else super_to_i(*args)
     end
   end
 

data/lib/sandwich/helpers/base.rb

@@ -1,6 +1,32 @@
 module Sandwich
   module Base
     module ClassMethods
+      def default_attribute(name = nil, &block)
+        if name
+          @default_attribute = name
+        elsif block_given?
+          @default_attribute = block
+        else
+          raise "Need an attribute name or a block for #{self}"
+        end
+      end
+
+      def default_attribute_args(value, op)
+        if @default_attribute.respond_to?(:call)
+          case @default_attribute.arity
+          when 1
+            @default_attribute.call(value)
+          when 2
+            @default_attribute.call(value, op)
+          else
+            raise ArgumentError, "the block sent to #{name}.default_attribute needs 1 or 2 arguments"
+          end
+        elsif @default_attribute
+          {@default_attribute => value}
+        else
+          raise "No default attribute defined for #{self}"
+        end
+      end
     end
   end
 end

data/lib/sandwich/model/base.rb

@@ -1,144 +1,19 @@
-require 'strscan'
+require 'sandwich/model/definition_scanner'
+require 'sandwich/model/materializer'
 
 module Sandwich
   class ModelNotFoundError < StandardError; end
 
-  class DefinitionScanner < StringScanner
-    def initialize(str, attribute_separators)
-      super
-      @attribute_separators = attribute_separators
-      model_definition
-    end
-
-    def model_definition
-      @model_definition ||= [determiner, model, attributes]
-    end
-
-    def determiner
-      @determiner ||= begin
-                        whitespace
-                        scan(/(?:an?|\d+|the)/).tap { whitespace }
-                      end
-    end
-
-    alias_method :raw_determiner, :determiner
-
-    def model
-      @model ||= begin
-                   whitespace
-                   @model = if has_attribute_separator?
-                              scan_until(/(?=\s+#{attribute_separators})/)
-                            else
-                              words
-                            end.tap { whitespace }
-                 end
-    end
-
-    alias_method :raw_model, :model
-
-    # assumes the scan pointer is past the model name
-    def attributes
-      whitespace
-
-      @raw_attributes = rest.strip
-      
-      if has_attribute_separator?
-        skip(/#{attribute_separators}/)
-        whitespace
-
-        attribute_pairs
-      else
-        attribute_value
-      end.tap { whitespace }
-    end
-
-    def raw_attributes
-      @raw_attributes
-    end
-
-    def attribute_separators
-      "(?:#{@attribute_separators.join('|')})"
-    end
-
-    def words
-      if w = scan(/\s*(?:\w+ ?)+/) then w.strip end
-    end
-
-    alias_method :attribute_name, :words
-
-    def whitespace
-      skip(/\s*/)
-    end
-
-    def attribute_value
-      skip(/\s*"/)
-
-      scan(/[^"]+/).tap { |val| skip(/(?:"|\s+)/) }
-    end
-
-    def has_attribute_separator?
-      check_until(/#{attribute_separators}/)
-    end
-
-    def attribute_pairs
-      result = []
-
-      while p = attribute_pair
-        result << p
-
-        scan(/\s*(?:and|,)\s*/)
-      end
-
-      Hash[*result.flatten]
-    end
-
-    def attribute_pair
-      w = attribute_name
-      v = attribute_value
-
-      if w.nil? || v.nil?
-        nil
-      else
-        [w, v]
-      end
-    end
-  end
-
   module Model
     def self.attribute_separators
       @attribute_separators = %w(with)
     end
 
     module Base
-      module Extensions
-        def default_attribute(name = nil, &block)
-          if name
-            @default_attribute = name
-          elsif block_given?
-            @default_attribute = block
-          else
-            raise "Need an attribute name or a block for #{self}"
-          end
-        end
-
-        def default_attribute_args(value, op)
-          if @default_attribute.respond_to?(:call)
-            case @default_attribute.arity
-            when 1
-              @default_attribute.call(value)
-            when 2
-              @default_attribute.call(value, op)
-            else
-              raise ArgumentError, "the block sent to #{name}.default_attribute needs 1 or 2 arguments"
-            end
-          elsif @default_attribute
-            {@default_attribute => value}
-          else
-            raise "No default attribute defined for #{self}"
-          end
-        end
+      def Materializer(name)
+        Materializer[name]
       end
-
+      
       def materialize!(match)
         determiner, model, values = definition(match).model_definition
         
@@ -161,6 +36,24 @@ module Sandwich
         DefinitionScanner.new(str, Sandwich::Model.attribute_separators)
       end
 
+      ##
+      # Create a record
+      def record!(name, args)
+        materializer = Materializer(name)
+
+        raise ModelNotFoundError, "No model found for '#{name}'" if materializer.nil?
+        
+        materializer.new(args)
+      end
+
+      def record(name, args)
+        materializer = Materializer(name)
+
+        raise ModelNotFoundError, "No model found for '#{name}'" if materializer.nil?
+
+        materializer.get(args)
+      end
+
       private
 
       def creator?(determiner)

data/lib/sandwich/model/definition_scanner.rb

@@ -0,0 +1,106 @@
+require 'strscan'
+
+module Sandwich
+  module Model
+    class DefinitionScanner < StringScanner
+      def initialize(str, attribute_separators)
+        super
+        @attribute_separators = attribute_separators
+        model_definition
+      end
+
+      def model_definition
+        @model_definition ||= [determiner, model, attributes]
+      end
+
+      def determiner
+        @determiner ||= begin
+                          whitespace
+                          scan(/\b(?:an?|\d+|the|no)\b/).tap { whitespace }
+                        end
+      end
+
+      alias_method :raw_determiner, :determiner
+
+      def model
+        @model ||= begin
+                     whitespace
+                     @model = if has_attribute_separator?
+                                scan_until(/(?=\s+#{attribute_separators})/)
+                              else
+                                words
+                              end.tap { whitespace }
+                   end
+      end
+
+      alias_method :raw_model, :model
+
+      # assumes the scan pointer is past the model name
+      def attributes
+        whitespace
+
+        @raw_attributes = rest.strip
+        
+        if has_attribute_separator?
+          skip(/#{attribute_separators}/)
+          whitespace
+
+          attribute_pairs
+        else
+          attribute_value
+        end.tap { whitespace }
+      end
+
+      def raw_attributes
+        @raw_attributes
+      end
+
+      def attribute_separators
+        "(?:#{@attribute_separators.join('|')})"
+      end
+
+      def words
+        if w = scan(/\s*(?:\w+ ?)+/) then w.strip end
+      end
+
+      alias_method :attribute_name, :words
+
+      def whitespace
+        skip(/\s*/)
+      end
+
+      def attribute_value
+        skip(/\s*"/)
+
+        scan(/[^"]+/).tap { |val| skip(/(?:"|\s+)/) }
+      end
+
+      def has_attribute_separator?
+        check_until(/#{attribute_separators}/)
+      end
+
+      def attribute_pairs
+        result = []
+
+        while p = attribute_pair
+          result << p
+
+          scan(/\s*(?:and|,)\s*/)
+        end
+
+        Hash[*result.flatten]
+      end
+
+      def attribute_pair
+        w = attribute_name
+        v = attribute_value
+
+        if w.nil? || v.nil?
+          nil
+        else
+          [w, v]
+        end
+      end
+    end
+  end
+end

data/lib/sandwich/model/machinist.rb

@@ -5,115 +5,38 @@ module Sandwich
     module Machinist
       include Model::Base
 
-      class Materializer
-        def self.named_fixtures
-          @named_fixtures ||= {}
-        end
-
-        def self.[](key)
-          key = prepare_key(key)
-
-          if model = named_fixtures[key]
-            new(key, model)
-          else
-            nil
-          end
-        end
-
-        def self.[]=(key, value)
-          key = prepare_key(key)
-
-          raise "Named fixture '#{key}' already exists for class #{self[key]}" if self[key]
-
-          named_fixtures[key] = value
-        end
-
-        def self.prepare_key(key)
-          key.to_s.underscore.to_sym
-        end
-
-        def initialize(key, model)
-          @key, @model = if (key.to_s == model.name.underscore)
-                           [:master, model]
-                         else
-                           [key, model]
-                         end
-        end
-
-        def get(args)
-          @model.find(:first, :conditions => prepare_args(args, :find)).tap do |result|
-            raise "Could not find model for args: #{args.inspect}" if result.nil?
-          end
-        end
-
-        def create(args = nil)
-          @model.make(@key, prepare_args(args, :create))
-        end
-
-        private
-        
-        def prepare_args(args, op)
-          case args
-          when Hash
-            Hash[*args.each_pair.map { |k, v| [k.underscore, prepare_value(k, v)] }.flatten]
-          when nil
-            {}
-          else
-            @model.default_attribute_args(args, op)
-          end
-        end
-
-        def prepare_value(key, value)
-          if assoc = @model.reflect_on_association(key.to_sym)
-            self.class[assoc.class_name].get(value)
-          else
-            value
-          end
+      class Materializer < Sandwich::Model::Materializer
+        def new(args = nil)
+          @model.make_unsaved(@key, prepare_args(args, :create))
         end
       end
 
+      def Materializer(name)
+        Materializer[name]
+      end
+      
       module Extensions
         include Sandwich::Model::Base::Extensions
 
         def blueprint(name = :master, &blueprints)
           if block_given?
-            m = Sandwich::Model::Machinist::Materializer
-            m[name == :master ? self.name.underscore : name] = self
+            Machinist::Materializer[self.name.underscore] = self unless name == :master
           end
 
           super
         end
       end
-
-
-      ##
-      # Create a record
-      def record!(name, args)
-        materializer = Materializer[name]
-
-        raise ModelNotFoundError, "No model found for '#{name}'" if materializer.nil?
-        
-        materializer.create(args)
-      end
-
-      def record(name, args)
-        materializer = Materializer[name]
-
-        raise ModelNotFoundError, "No model found for '#{name}'" if materializer.nil?
-
-        materializer.get(args)
-      end
     end
   end
 end
 
 if defined?(ActiveRecord::Base)
   require 'machinist/active_record'
+  require 'machinist/object'
   
   ActiveRecord::Base.send(:extend, Sandwich::Model::Machinist::Extensions)
 else
   raise "Don't know which machinist adapter to use."
 end
 
-
 World(Sandwich::Model::Machinist)

data/lib/sandwich/model/materializer.rb

@@ -0,0 +1,67 @@
+module Sandwich
+  module Model
+    class Materializer
+      def self.named_fixtures
+        @named_fixtures ||= {}
+      end
+
+      def self.[](key)
+        key   = prepare_key(key)
+        key_s = key.to_s
+
+        if model = named_fixtures[key]
+          new(key, model)
+        else
+          new(key, key_s.classify.constantize) rescue nil
+        end
+      end
+
+      def self.[]=(key, value)
+        key = prepare_key(key)
+
+        raise "Named fixture '#{key}' already exists for class #{self[key]}" if self[key]
+
+        named_fixtures[key] = value
+      end
+
+      def self.prepare_key(key)
+        key.to_s.underscore.to_sym
+      end
+
+      def initialize(key, model)
+        @key, @model = if (key.to_s == model.name.underscore)
+                         [:master, model]
+                       else
+                         [key, model]
+                       end
+      end
+
+      def get(args)
+        @model.find(:first, :conditions => prepare_args(args, :find)).tap do |result|
+          raise "Could not find model for args: #{args.inspect}" if result.nil?
+        end
+      end
+
+      private
+      
+      def prepare_args(args, op)
+        case args
+        when Hash
+          Hash[*args.each_pair.map { |k, v| [k.underscore, prepare_value(k, v)] }.flatten]
+        when nil
+          {}
+        else
+          @model.default_attribute_args(args, op)
+        end
+      end
+
+      def prepare_value(key, value)
+        if assoc = @model.reflect_on_association(key.to_sym)
+          self.class[assoc.class_name].get(value)
+        else
+          value
+        end
+      end
+    end
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 17
-  version: 0.0.17
+  - 18
+  version: 0.0.18
 platform: ruby
 authors: 
 - David Leal
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-20 00:00:00 +01:00
+date: 2010-06-02 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -97,6 +97,7 @@ files:
 - VERSION
 - lib/sandwich.rb
 - lib/sandwich/cucumber/debug_steps.rb
+- lib/sandwich/cucumber/ivar_steps.rb
 - lib/sandwich/cucumber/model_steps.rb
 - lib/sandwich/cucumber/table_steps.rb
 - lib/sandwich/cucumber/time_steps.rb
@@ -111,7 +112,9 @@ files:
 - lib/sandwich/helpers/associations.rb
 - lib/sandwich/helpers/base.rb
 - lib/sandwich/model/base.rb
+- lib/sandwich/model/definition_scanner.rb
 - lib/sandwich/model/machinist.rb
+- lib/sandwich/model/materializer.rb
 - spec/sandwich_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb