sandwich 0.0.9 → 0.0.11

data/VERSION

@@ -1 +1 @@
-0.0.9
+0.0.11

data/lib/sandwich/cucumber/model_steps.rb

@@ -1,35 +1,17 @@
 require 'sandwich/ext/string'
-require 'sandwich/cucumber/world'
 
-Given /^((?:an?|the|\d+) .+)$/ do |what|
-  # la la la la
-end
-
-Transform /(an?|\d+) (.+) #{qc}$/ do |total, what, value|
-  model = attr = nil
-
-  begin
-    model = class_for(what)
-    attr  = model.default_attribute
-  rescue NameError
-    what, attr = *what.split(/(?:with|in)/).map(&:strip)
-    model = class_for(what)
-  end
-
-  raise "No attribute passed and no default attribute defined for #{model}" if attr.nil?
+Given /^((?:an?|the|\d+) .+)$/ do |what| end
 
-  r = total.times.map { model.make(attr.to_s.underscore => value) }
-  
-  r.length == 1 ? r.first : r
+Transform /(?:an?|\d+) .+/ do |match|
+  materialize!(match)
 end
 
-Transform /the (.+) #{qc}$/ do |what, attr, value|
-  class_for(what).find(:first, :conditions => {attr => value})
+Given /^(an?|the|\d+) (.+) with the following attributes:$/ do |total, what, table|
+  total.times { record!(what, table.rows_hash) }
 end
 
-Transform /the (.+) #{qc}$/ do |what, value|
-  klass = class_for(what)
-  klass.find(:first, :conditions => {klass.default_attribute => value})
+Transform /the (.+?) "([^\"]*)"$/ do |what, value|
+  record(what, value)
 end
 
 Given /^(.+) belong(?:ing|s) to (.+)$/ do |child, parent|
@@ -41,27 +23,8 @@ Given /^(.+) has (.+)$/ do |parent, child|
   parent.send(child.class.name.underscore.pluralize) << child
 end
 
-Given /^no (.+) exists?$/ do |what|
-  class_for(what).delete_all
-end
-
-Given /^no (.+) (?:with|in) (.+) #{qc} exists?$/ do |what, attr, value|
-  class_for(what).delete_all
-end
-
-Given /^(an?|the|\d+) (.+) with the following attributes:$/ do |total, what, table|
-  class_for(what).tap do |model|
-    total.times do
-      model.make(Hash[*table.raw.map { |k, v| [k.underscore, value_for(model, k, v)] }.flatten])
-    end
-  end
-end
-
 Given /^the following (.+):$/ do |what, table|
-  class_for(what.singularize).tap do |model|
-    table.hashes.each do |h|
-      model.make(Hash[*h.each_pair.map { |(k, v)| [k.underscore, value_for(model, k, v)] }.flatten])
-    end
-  end
-end
+  model = what.singularize
 
+  table.hashes.each { |h| record!(model, h) }
+end

data/lib/sandwich/cucumber/world.rb

@@ -1,18 +1,5 @@
 module Sandwich
   module World
-    def class_for(name)
-      name.underscore.classify.constantize
-    end
-
-    def value_for(model, attr, value)
-      if assoc = model.reflect_on_association(attr.to_sym)
-        assoc_class = assoc.class_name.constantize
-        assoc_class.find_or_make(assoc_class.default_attribute_query(value))
-      else
-        value
-      end
-    end
-
     def xpath(unknown_selector)
       kind, selector = if Array === unknown_selector
                          [unknown_selector[0].to_sym, unknown_selector[1]]

data/lib/sandwich/helpers/base.rb

@@ -1,17 +1,6 @@
 module Sandwich
   module Base
     module ClassMethods
-      def default_attribute(name = nil)
-        if name
-          @default_attribute = name
-        else
-          @default_attribute or raise "No default attribute defined for #{self}"
-        end
-      end
-
-      def default_attribute_query(value)
-        {default_attribute => value}
-      end
     end
   end
 end

data/lib/sandwich/model/base.rb

@@ -0,0 +1,106 @@
+require 'strscan'
+
+module Sandwich
+  module StringScannerExt
+    def words
+      if w = scan(/\s*(?:\w+ ?)+/) then w.strip end
+    end
+
+    alias_method :model_name, :words
+    alias_method :attribute_name, :words
+
+    def attribute_value
+      skip(/\s*"/)
+
+      scan(/[^"]+/).tap { |val| skip(/(?:"|\s+)/) }
+    end
+
+    def attribute_pairs
+      result = []
+
+      while p = attribute_pair
+        result << p
+
+        scan(/\s*(?:and|,)\s*/)
+      end
+
+      Hash[*result.flatten]
+    end
+
+    ::StringScanner.send(:include, self)
+
+    private 
+
+    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.attr_separators
+      @attr_separators = %w(with)
+    end
+
+    def self.attr_sep_str
+      "(?:#{attr_separators.join('|')})"
+    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
+            @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)
+            @default_attribute.call(value, op)
+          elsif @default_attribute
+            {@default_attribute => value}
+          else
+            raise "No default attribute defined for #{self}"
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/sandwich/model/machinist.rb

@@ -0,0 +1,131 @@
+require 'sandwich/model/base'
+
+module Sandwich
+  module Model
+    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 = key, model
+        end
+
+        def get(args)
+          args = prepare_args(args)
+
+          result = case args
+                   when Hash
+                     @model.find(:first, :conditions => args)
+                   else
+                     @model.find(:first, :conditions => @model.default_attribute_args(args, :find))
+                   end
+          
+          raise "Could not find model for args: #{args.inspect}" if result.nil?
+
+          result
+        end
+
+        def create(args = nil)
+          args = prepare_args(args)
+
+          case args
+          when Hash
+            @model.make(@key, args)
+          else
+            @model.make(@key, @model.default_attribute_args(args, :create))
+          end
+        end
+
+        private
+        
+        def prepare_args(args)
+          case args
+          when Hash
+            Hash[*args.each_pair.map { |k, v| [k.underscore, prepare_value(k, v)] }.flatten]
+          when nil
+            {}
+          else
+            args
+          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
+
+      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
+          end
+
+          super
+        end
+      end
+
+
+      ##
+      # Create a record
+      def record!(name, args)
+        materializer = Materializer[name]
+
+        return name if materializer.nil?
+        
+        materializer.create(args)
+      end
+
+      def record(name, args)
+        materializer = Materializer[name]
+
+        return name if materializer.nil?
+
+        materializer.get(args)
+      end
+    end
+  end
+end
+
+if defined?(ActiveRecord::Base)
+  require 'machinist/active_record'
+  
+  ActiveRecord::Base.send(:extend, Sandwich::Model::Machinist::Extensions)
+else
+  raise "Don't know which machinist adapter to use."
+end
+
+
+World(Sandwich::Model::Machinist)

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 9
-  version: 0.0.9
+  - 11
+  version: 0.0.11
 platform: ruby
 authors: 
 - David Leal
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-29 00:00:00 +01:00
+date: 2010-05-06 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -110,6 +110,8 @@ files:
 - lib/sandwich/helpers/amounts.rb
 - lib/sandwich/helpers/associations.rb
 - lib/sandwich/helpers/base.rb
+- lib/sandwich/model/base.rb
+- lib/sandwich/model/machinist.rb
 - spec/sandwich_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb