olfactory 0.0.1 → 0.1.0

data/lib/olfactory/template.rb

@@ -9,6 +9,7 @@ module Olfactory
     end
 
     def build(block, options = {})
+      self.add_defaults(:before) if options[:defaults].nil? || options[:defaults]
       if block # Block can be nil (when we want only defaults)
         if options[:value]
           block.call(self, options[:value])
@@ -16,61 +17,189 @@ module Olfactory
           block.call(self)
         end
       end
-      if options[:defaults].nil? || options[:defaults]
-        # Only set defaults if configuration wasn't specified
-        self.add_defaults
-      end
+      self.add_defaults(:after) if options[:defaults].nil? || options[:defaults]
 
       self
     end
 
+    def save!
+      # Items, then subtemplates
+      [self.definition.t_items, self.definition.t_subtemplates].each do |field_group_definitions|
+        field_group_definitions.each do |field_name, field_definition|
+          if field_value = self[field_name]
+            if field_definition[:collection] && field_definition[:collection] <= Array
+              field_value.each { |value| value.save! if value.respond_to?(:save!) }
+            elsif field_definition[:collection] && field_definition[:collection] <= Hash
+              field_value.values.each { |value| value.save! if value.respond_to?(:save!) }
+            else
+              field_value.save! if field_value.respond_to?(:save!)
+            end
+          end
+        end
+      end
+    end
+
     def method_missing(meth, *args, &block)
       # Explicit fields
-      if (definition.t_macros.has_key?(meth) || definition.t_subtemplates.has_key?(meth) || definition.t_items.has_key?(meth))
-        if definition.t_macros.has_key?(meth)
-          field_type = :macro
-          definition_of_field = definition.t_macros[meth]
-          field_value = build_macro(definition_of_field, args, block)
-        elsif definition.t_subtemplates.has_key?(meth) && !(self.default_mode && self.has_key?(meth))
-          field_type = :subtemplate
-          definition_of_field = definition.t_subtemplates[meth]
-          subtemplate_name = definition_of_field.has_key?(:template) ? definition_of_field[:template] : meth
-          field_value = build_subtemplate(Olfactory.templates[subtemplate_name], args, block)
-        elsif definition.t_items.has_key?(meth) && !(self.default_mode && self.has_key?(meth))
-          field_type = :item
-          definition_of_field = definition.t_items[meth]
-          field_value = build_item(definition_of_field, args, block)
-        end
-        # Add field value to template
-        if field_type && field_type != :macro
-          if definition_of_field[:collection]
-            self[meth] = [] if !self.has_key?(meth)
-            if field_type == :subtemplate && field_value.class <= Array
-              self[meth].concat(field_value)
+      if field_definition = self.definition.find_field_definition(meth)
+        populate_field(field_definition, meth, args, block)
+      else
+        super # Unknown method
+      end
+    end
+    def can_set_field?(meth)
+      !(self.default_mode && self.has_key?(meth))
+    end
+    def extract_variable_name(args)
+      variable_name = args.first
+      raise "Must provide a name when adding to a named field!" if variable_name.nil?
+      variable_name
+    end
+    def populate_field(field_definition, meth, args, block)
+      if field_definition[:type] == :macro
+        field_value = build_macro(field_definition, args, block)
+        do_not_set_value = true
+      elsif field_definition[:type] == :subtemplate && can_set_field?(meth)
+        subtemplate_name = field_definition.has_key?(:template) ? field_definition[:template] : field_definition[:name]
+        subtemplate_definition = Olfactory.templates[subtemplate_name]
+        subtemplate_definition ||= Olfactory.templates[field_definition[:singular]]
+        if subtemplate_definition
+          if field_definition[:collection] && field_definition[:collection] <= Array
+            # Embeds many
+            if meth == field_definition[:singular]
+              # Singular
+              grammar = :singular
+              preset_name = args.first
+
+              field_value = build_one_subtemplate(subtemplate_definition, preset_name, block)
+            else
+              # Plural
+              grammar = :plural
+              quantity = args.detect { |value| value.class <= Integer }
+              preset_name = args.detect { |value| value != quantity }
+
+              field_value = build_many_subtemplates(subtemplate_definition, quantity, preset_name, block)
+              do_not_set_value if field_value.nil?
+            end
+          elsif field_definition[:collection] && field_definition[:collection] <= Hash
+            # Embeds many named
+            if meth == field_definition[:singular]
+              # Singular
+              grammar = :singular
+              variable_name = extract_variable_name(args)
+              args = args[1..(args.size-1)]
+              preset_name = args.first
+              
+              field_value = build_one_subtemplate(subtemplate_definition, preset_name, block)
+              do_not_set_value if field_value.nil? # || field_value.empty?
             else
-              self[meth] << field_value
+              # Plural
+              grammar = :plural
+              do_not_set_value = true
+              # UNSUPPORTED
             end
           else
-            self[meth] = field_value
+            # Embeds one
+            preset_name = args.first
+
+            field_value = build_one_subtemplate(subtemplate_definition, preset_name, block)
+            do_not_set_value if field_value.nil?
+          end
+        else
+          raise "Could not find a template matching '#{subtemplate_name}'!"
+        end
+      elsif field_definition[:type] == :item && can_set_field?(meth)
+        if field_definition[:collection] && field_definition[:collection] <= Array
+          # Has many
+          if meth == field_definition[:singular]
+            # Singular
+            grammar = :singular
+            obj = args.count == 1 ? args.first : args
+            
+            field_value = build_one_item(field_definition, obj, block)
+            do_not_set_value = true if field_value.nil?
+          else
+            # Plural
+            grammar = :plural
+            quantity = args.first if block && args.first.class <= Integer
+            arr = args.first if args.count == 1 && args.first.class <= Array
+
+            field_value = build_many_items(field_definition, quantity, arr, args, block)
+            do_not_set_value = true if field_value.empty?
+          end
+        elsif field_definition[:collection] && field_definition[:collection] <= Hash
+          # Has many named
+          if meth == field_definition[:singular]
+            # Singular
+            grammar = :singular
+            variable_name = extract_variable_name(args)
+            args = args[1..(args.size-1)]
+            obj = args.first
+
+            field_value = build_one_item(field_definition, obj, block)
+            do_not_set_value = true if field_value.nil?
+          else
+            # Plural
+            grammar = :plural
+            hash = args.first if args.first.class <= Hash
+
+            # Hash
+            if hash
+              field_value = hash
+            end
+            do_not_set_value = true if field_value.nil? || field_value.empty?
           end
+        else
+          # Has one
+          obj = args.first
+            
+          field_value = build_one_item(field_definition, obj, block)
         end
-      # No field definition
       else
-        super # Unknown method
+        do_not_set_value = true
+      end
+
+      # Add field value to template
+      if !do_not_set_value
+        if field_definition[:collection]
+          self[field_definition[:name]] ||= field_definition[:collection].new
+          if field_definition[:collection] <= Array
+            if grammar == :plural
+              return_value = self[field_definition[:name]].concat(field_value)
+            elsif grammar == :singular
+              return_value = self[field_definition[:name]] << field_value
+            end
+          elsif field_definition[:collection] <= Hash
+            if grammar == :plural
+              return_value = self[field_definition[:name]].merge!(field_value)
+            elsif grammar == :singular
+              return_value = self[field_definition[:name]][variable_name] = field_value
+            end
+          end
+        else
+          return_value = self[field_definition[:name]] = field_value
+        end
       end
+      return_value
     end
     def transient(name, value)
       self.transients[name] = value if !(self.default_mode && self.transients.has_key?(name))
     end
-    def add_defaults
+    def add_defaults(mode)
       # Prevents overwrites of custom values by defaults
       self.default_mode = true # Hackish for sure, but its efficient...
 
-      default_definition = definition.t_default
+      case mode
+      when :before
+        default_definition = definition.t_before
+      when :after
+        default_definition = definition.t_after
+      end
+          
       if default_definition[:evaluator]
         default_definition[:evaluator].call(self)
-      elsif default_definition[:preset_name]
-        preset_definition = definition.find_preset_definition(default_definition[:preset_name])
+      elsif default_definition[:preset]
+        preset_definition = definition.find_preset_definition(default_definition[:preset])
         preset_definition[:evaluator].call(self)
       end
 
@@ -81,22 +210,51 @@ module Olfactory
         macro_definition[:evaluator].call(self, *args)
       end
     end
-    def build_subtemplate(subtemplate_definition, args, block)
+    def build_one_subtemplate(subtemplate_definition, preset_name, block)
+      # Block
       if block
         subtemplate_definition.build(block, :transients => self.transients)
+      # Preset Name
+      elsif preset_name
+        subtemplate_definition.build_preset(preset_name, 1, :transients => self.transients)
+      # Default (nothing)
+      else
+        subtemplate_definition.build(nil, :transients => self.transients)
+      end
+    end
+    def build_many_subtemplates(subtemplate_definition, quantity, preset_name, block)
+      # Integer, Block
+      if quantity && block
+        Array.new(quantity) { subtemplate_definition.build(block, :transients => self.transients) }
+      # Integer, Preset Name
+      elsif quantity && preset_name
+        subtemplate_definition.build_preset(preset_name, quantity, :transients => self.transients)
+      # Integer
+      elsif quantity
+        Array.new(quantity) { subtemplate_definition.build(nil, :transients => self.transients) }
       else
-        subtemplate_definition.build_preset((args.count == 1 ? args.first : args), :transients => self.transients)
+        nil
       end
     end
-    def build_item(item_definition, args, block)
+    def build_one_item(item_definition, obj, block)
       if block
-        block.call(*args)
+        block.call
+      elsif obj
+        obj
       else
-        if item_definition[:evaluator]
-          item_definition[:evaluator].call(*args)
-        else
-          args.count == 1 ? args.first : argsnew
-        end
+        nil
+      end
+    end
+    def build_many_items(item_definition, quantity, arr, args, block)
+      # Integer, Block
+      if quantity && block
+        Array.new(quantity) { block.call }
+      # Array
+      elsif arr
+        arr
+      # Object, Object...
+      else
+        args
       end
     end
   end

data/lib/olfactory/template_definition.rb

@@ -1,82 +1,147 @@
 # -*- encoding : utf-8 -*-
 module Olfactory
   class TemplateDefinition
-    attr_accessor :t_items, :t_subtemplates, :t_macros, :t_presets, :t_default
+    attr_accessor :t_items, :t_subtemplates, :t_macros, :t_presets, :t_before, :t_after
 
     def initialize
       self.t_items = {}
       self.t_subtemplates = {}
       self.t_macros = {}
       self.t_presets = {}
-      self.t_default = {}
+      self.t_before = {}
+      self.t_after = {}
     end
 
     def build(block, options = {})
-      if options[:preset]
-        self.build_preset(options[:preset], options.reject { |k,v| k == :preset })
+      if options[:preset] || options[:quantity]
+        self.build_preset(options[:preset], (options[:quantity] || 1), options.reject { |k,v| [:preset, :quantity].include?(k) })
       else
         new_template = Template.new(self, options)
         new_template.build(block, options)
       end
       new_template
     end
-    def build_preset(preset_name, options = {})
-      if preset_name.class <= Integer
+    def build_preset(preset_name, quantity, options = {})
+      raise "Quantity must be an integer!" if !(quantity.class <= Integer)
+
+      if quantity > 1
         # Build multiple
-        Array.new(preset_name) { self.build(nil, options) }
-      elsif preset_definition = self.find_preset_definition(preset_name)
-        # Build single
-        new_template = Template.new(self, options)
-        preset_block = preset_definition[:evaluator]
-        if preset_definition[:preset_name].class == Regexp
-          new_template.build(preset_block, options.merge(:value => preset_name))
+        if preset_name
+          Array.new(quantity) { self.build_preset(preset_name, 1, options) }
         else
-          new_template.build(preset_block, options)
+          Array.new(quantity) { self.build(nil, options) }
         end
-      else
-        raise "Missing preset matching '#{preset_value}' for template!"
+      elsif quantity == 1
+        if preset_definition = self.find_preset_definition(preset_name)
+          # Build single
+          new_template = Template.new(self, options)
+          preset_block = preset_definition[:evaluator]
+          if preset_definition[:regexp]
+            new_template.build(preset_block, options.merge(:value => preset_name))
+          else
+            new_template.build(preset_block, options)
+          end
+        elsif preset_name.nil?
+          self.build(nil, options)
+        else
+          raise "Missing preset matching '#{preset_name}' for template!"
+        end
+      else quantity <= 0
+        raise "Can't build 0 or less items!"
       end
     end
 
-    def find_preset_definition(preset_name)
-      preset_definition = self.t_presets[preset_name]
+    def find_field_definition(name)
+      definition = find_macro_definition(name)
+      definition ||= find_subtemplate_definition(name)
+      definition ||= find_item_definition(name)
+      definition
+    end
+
+    def find_definition_in_list(name, definition_list)
+      definition = definition_list[name]
+      definition ||= definition_list.values.detect do |v|
+        v.has_key?(:alias) && (v[:alias] == name || (v.respond_to?("include") && v.include?(name)))
+      end
+      definition
+    end
+
+    def find_macro_definition(name)
+      self.find_definition_in_list(name, self.t_macros)
+    end
+
+    def find_subtemplate_definition(name)
+      definition = self.find_definition_in_list(name, self.t_subtemplates)
+      definition ||= self.t_subtemplates.values.detect { |v| v.has_key?(:singular) && v[:singular] == name }
+      definition
+    end
+
+    def find_item_definition(name)
+      definition = self.find_definition_in_list(name, self.t_items)
+      definition ||= self.t_items.values.detect { |v| v.has_key?(:singular) && v[:singular] == name }
+      definition
+    end
+
+    def find_preset_definition(name)
+      preset_definition = self.find_definition_in_list(name, self.t_presets)
       if preset_definition.nil?
         # Try to find a regexp named preset that matches
-        preset_name = self.t_presets.keys.detect { |p_name| p_name.class == Regexp && p_name.match(preset_name.to_s) }
-        preset_definition = self.t_presets[preset_name] if preset_name
+        name = self.t_presets.keys.detect { |p_name| p_name.class == Regexp && p_name.match(name.to_s) }
+        preset_definition = self.t_presets[name] if name
       end
       preset_definition
     end
 
     # Defines a value holding field
     def has_one(name, options = {}, &block)
-      self.t_items[name] = { :evaluator => block }.merge(options)
+      self.t_items[name] = {  :type => :item,
+                              :name => name,
+                              :evaluator => block
+                            }.merge(options)
     end
     def has_many(name, options = {}, &block)
-      self.t_items[name] = { :evaluator => block, :collection => true }.merge(options)
+      self.has_one(name, options.merge(:collection => (options[:named] ? Hash : Array)), &block)
     end
 
     # Defines a hash-holding field
     def embeds_one(name, options = {}, &block)
-      self.t_subtemplates[name] = { :evaluator => block }.merge(options)
+      self.t_subtemplates[name] = { :type => :subtemplate,
+                                    :name => name,
+                                    :evaluator => block 
+                                  }.merge(options)
     end
     def embeds_many(name, options = {}, &block)
-      self.t_subtemplates[name] = { :evaluator => block, :collection => true }.merge(options)
+      self.embeds_one(name, options.merge(:collection => (options[:named] ? Hash : Array)), &block)
     end
 
     # Defines a macro
     def macro(name, options = {}, &block)
-      self.t_macros[name] = { :evaluator => block }.merge(options)
+      self.t_macros[name] = { :type => :macro,
+                              :name => name,
+                              :evaluator => block 
+                            }.merge(options)
     end
 
     # Defines a preset of values
     def preset(name, options = {}, &block)
-      self.t_presets[name] = { :evaluator => block }.merge(options)
+      self.t_presets[name] = {  :type => :preset,
+                                :name => name,
+                                :evaluator => block
+                              }.merge(options)
+      self.t_presets[name] = self.t_presets[name].merge(:regexp => name) if name.class <= Regexp
     end
 
     # Defines defaults
-    def default(preset_name = nil, options = {}, &block)
-      self.t_default = { :preset_name => preset_name, :evaluator => block }.merge(options)
+    def before(options = {}, &block)
+      self.t_before = { :type => :default,
+                        :evaluator => block
+                      }.merge(options)
+      self.t_before = self.t_before.merge(:preset => options[:preset]) if options[:preset]
+    end
+    def after(options = {}, &block)
+      self.t_after = {  :type => :default,
+                        :evaluator => block }.merge(options)
+      self.t_after = self.t_after.merge(:preset => options[:preset]) if options[:preset]
     end
   end
 end

data/lib/olfactory/version.rb

@@ -1,3 +1,3 @@
 module Olfactory
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

data/lib/olfactory.rb

@@ -17,6 +17,11 @@ module Olfactory
   def self.build_template(name, options = {}, &block)
     self.templates[name].build(block, options)
   end
+  def self.create_template(name, options = {}, &block)
+    template = self.templates[name].build(block, options)
+    template.save!
+    template
+  end
 
   def self.reload
     @@templates = {}

data/olfactory.gemspec

@@ -16,8 +16,8 @@ Gem::Specification.new do |s|
   s.require_paths = ['lib']
   s.required_ruby_version = Gem::Requirement.new(">= 1.9.2")
 
-  s.add_development_dependency("rspec",    "~> 1.3.2")
-  s.add_development_dependency("pry")
-  s.add_development_dependency("pry-nav")
-  s.add_development_dependency("pry-stack_explorer")
+  s.add_development_dependency("rspec", "~> 3.1")
+  s.add_development_dependency("pry", "~> 0.10")
+  s.add_development_dependency("pry-nav", "~> 0.2")
+  s.add_development_dependency("pry-stack_explorer", "~> 0.4.9")
 end