sandwich 0.0.11 → 0.0.12

data/VERSION

@@ -1 +1 @@
-0.0.11
+0.0.12

data/lib/sandwich/cucumber/model_steps.rb

@@ -14,8 +14,15 @@ Transform /the (.+?) "([^\"]*)"$/ do |what, value|
   record(what, value)
 end
 
-Given /^(.+) belong(?:ing|s) to (.+)$/ do |child, parent|
-  child.send("#{parent.class.name.underscore}=", parent)
+Given /^(.+) belong(?:ing|s) to (an?|the) (.+)$/ do |child, determiner, rest|
+  d = definition("#{determiner} #{rest}")
+  a = child.class.reflect_on_association(d.raw_model.underscore.to_sym)
+  
+  raise "No association found for #{d.raw_model}" unless a
+
+  parent = materialize!("#{d.raw_determiner} #{a.class_name} #{d.raw_attributes}")
+
+  child.send("#{d.raw_model.underscore}=", parent)
   child.save!
 end
 

data/lib/sandwich/model/base.rb

@@ -1,20 +1,83 @@
 require 'strscan'
 
 module Sandwich
-  module StringScannerExt
+  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 :model_name, :words
     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 = []
 
@@ -27,10 +90,6 @@ module Sandwich
       Hash[*result.flatten]
     end
 
-    ::StringScanner.send(:include, self)
-
-    private 
-
     def attribute_pair
       w = attribute_name
       v = attribute_value
@@ -44,41 +103,11 @@ module Sandwich
   end
 
   module Model
-    def self.attr_separators
-      @attr_separators = %w(with)
-    end
-
-    def self.attr_sep_str
-      "(?:#{attr_separators.join('|')})"
+    def self.attribute_separators
+      @attribute_separators = %w(with)
     end
 
     module Base
-      def materialize!(match)
-        scanner    = StringScanner.new(match)
-
-        determiner = scanner.scan(/(?:an?|\d+)/)
-        scanner.skip(/\s+/)
-
-        model, values = if scanner.check_until(/#{_model.attr_sep_str}/)
-                          model = scanner.scan_until(/(?=\s+#{_model.attr_sep_str})/)
-                          scanner.skip(/\s+#{_model.attr_sep_str}\s+/)
-
-                          [model, scanner.attribute_pairs]
-                        else
-                          [scanner.model_name, scanner.attribute_value]
-                        end
-
-        if determiner.to_i == 1
-          record!(model, values)
-        else
-          determiner.times.map { record!(model, values) }
-        end
-      end
-
-      def _model
-        Sandwich::Model
-      end
-
       module Extensions
         def default_attribute(name = nil, &block)
           if name
@@ -100,6 +129,30 @@ module Sandwich
           end
         end
       end
+
+      def materialize!(match)
+        determiner, model, values = definition(match).model_definition
+
+        if creator?(determiner)
+          if determiner.to_i == 1
+            record!(model, values)
+          else
+            determiner.times.map { record!(model, values) }
+          end
+        else
+          record(model, values)
+        end
+      end
+
+      def definition(str)
+        DefinitionScanner.new(str, Sandwich::Model.attribute_separators)
+      end
+
+      private
+
+      def creator?(determiner)
+        determiner =~ /(an?|\d+)/
+      end
     end
   end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 11
-  version: 0.0.11
+  - 12
+  version: 0.0.12
 platform: ruby
 authors: 
 - David Leal