anaf_habtm 0.0.82 → 0.0.83

data/Rakefile

@@ -2,7 +2,7 @@ require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'
 
-VERSION = "0.0.82"
+VERSION = "0.0.83"
 
 desc 'Default: run unit tests.'
 task :default => :test

data/anaf_habtm.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{anaf_habtm}
-  s.version = "0.0.82"
+  s.version = "0.0.83"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tyler Gannon"]
-  s.date = %q{2010-07-11}
+  s.date = %q{2010-07-12}
   s.description = %q{accepts_nested_attributes_for habtm}
   s.email = %q{t--g__a--nnon@gmail.com}
   s.extra_rdoc_files = [
@@ -21,12 +21,13 @@ Gem::Specification.new do |s|
      "Rakefile",
      "anaf_habtm.gemspec",
      "install.rb",
-     "lib/anaf_active_record.rb",
      "lib/anaf_habtm.rb",
-     "lib/application_helper_methods.rb",
+     "lib/anaf_habtm/anaf_active_record.rb",
+     "lib/anaf_habtm/application_helper_methods.rb",
+     "lib/anaf_habtm/hash.rb",
+     "lib/anaf_habtm/string_reader.rb",
      "lib/generators/anaf_habtm/anaf_habtm_generator.rb",
      "lib/generators/anaf_habtm/assets/nested_attributes.js",
-     "lib/hash.rb",
      "rails/init.rb",
      "test/anaf_habtm_test.rb",
      "test/test_helper.rb",

data/lib/anaf_habtm/anaf_active_record.rb

@@ -0,0 +1,159 @@
+
+module AnafHabtm
+  module ActiveRecord
+    # options = {:named=>"name", 
+    #            :ar_options=>{:autosave=>true}}
+    def anaf_habtm(association, options={}, &block)
+      raise "Must specify :find or a code block." if (block.nil? && !options.has_key?(:find) && !options[:create])
+      class_eval do
+        # Define a proc that will look up the (potentially) existing object
+        finder = proc {|id| association.to_s.singularize.camelize.constantize.where(:id=>id).first
+        }
+        
+        # Define a proc that will set the association collection
+        set_collection = proc {|me, coll| me.send("#{association.to_s.tableize}=", coll)}
+        has_and_belongs_to_many association.to_sym, options[:ar_options]||={}
+        # Define the actual association setter.
+        define_method "#{association.to_s.tableize}_attributes=", lambda{|attributes_for_association|
+          coll = []
+          klass = association.to_s.singularize.camelize.constantize
+          attributes_for_association.each_value do |params|
+            next if params["_destroy"] == "1"
+            obj = finder.call(params["id"]) if params.has_key?("id")
+            params.extend(AnafHabtm::HashExtension)
+            params_copy = params.copy_without_destroy
+            # ActiveRecord::Base.attributes=() doesn't like extra parameters.
+            if block.nil?
+              unless obj
+                srch = klass
+                options[:find].each do |scope, name|
+                  if name.class==Hash
+                    srch = klass.send(scope, params[name.first[0].to_s][name.first[1].to_s])
+                  else
+                    srch = klass.send(scope, params[name.to_s])
+                  end
+                  obj = srch.first
+                end
+                obj = obj ||= klass.new if options[:create]
+
+                unless obj
+                  raise "Couldn't find or create #{association} named #{name}." 
+                end
+              end
+              obj.attributes = params_copy
+              obj.save
+              coll << obj
+            else
+              coll << block.call(params_copy, obj)
+            end
+          end
+          set_collection.call(self, coll)
+        }
+      end
+    end
+    
+    def association_text(association, opts={})
+      raise "Must give a name for text_association" unless opts.has_key?(:name)
+      class_eval do
+        if opts.has_key?(:class_name)
+          klass = opts[:class_name].constantize
+        else
+          klass = association.to_s.singularize.camelize.constantize
+        end
+        define_method "#{association.to_s}_text=", lambda{ |text|
+          return if text.empty?
+          coll = StringReader.new.read_items(text) do |name, commentary|
+            a = klass.undecorate(name) if klass.methods.include?("undecorate")
+            if opts.has_key?(:scope)
+              obj = self.send(association).scopes[opts[:scope]].call(name).first
+            end
+            params = {opts[:name]=>name}
+            params[opts[:commentary]] = commentary if opts.has_key?(:commentary)
+            obj = obj ||= klass.new
+            obj = klass.find(obj) unless obj.new_record?
+            obj.decoration = a if a
+            obj.attributes = params
+            obj.save
+            obj
+          end
+          self.send("#{association.to_s}=", coll)
+        }
+        
+        define_method "#{association.to_s}_text", lambda{
+          StringReader.new.write_items(self.send(association.to_s)) do |item|
+            name = item.send(opts[:name])
+            name = item.decorate(name) if item.methods.include?("decorate")
+            [name, opts.has_key?(:commentary) ? item.send(opts[:commentary]) : ""]
+          end
+        }
+      end
+    end
+    
+    def named_association(member, attribute, opts={})
+      member = member.to_s
+      klass = (opts.has_key?(:class_name) ? opts[:class_name] : member.to_s.singularize.camelize).constantize
+      attribute = attribute.to_s
+      if opts.has_key?(:create)
+        class_eval do
+          define_method "#{member}_#{attribute}=", lambda{|value|
+            return if value.blank?
+            obj = klass.named(value)
+            obj = obj ||= klass.create(attribute => value)
+            self.send("#{member}=", obj)
+          }
+        end
+      else
+        class_eval do
+          define_method "#{member}_#{attribute}=", lambda{|value|
+            self.send("#{member}=",klass.named(value)) unless value.blank?
+          }
+        end
+      end
+      class_eval "def #{member}_#{attribute}; 
+         #{member}.#{attribute} if #{member};
+       end;"
+    end
+    
+    def search_on(*cols)
+      class_eval "def self.search_columns; #{cols.map{|t| t.to_s}.to_ary.inspect}; end;"
+      class_eval do
+        scope :search, lambda{|str|
+          items = like_condition(str.downcase)
+          if scopes.has_key?(:search_mod)
+            items = items.search_mod
+          end
+          items
+        }
+        scope :with_name, lambda{|str|
+          equals_condition(str.downcase).limit(1)
+        }
+      end
+    end
+    
+    def lookup(params)
+      str = params[:id]
+      if str.match(/\D/)
+        named(str)
+      else
+        find(str)
+      end
+    end
+
+    def like_condition(str)
+      where(condition("ilike '%#{str}%'"))
+    end
+
+    def equals_condition(str)
+      where(condition("= '#{str.downcase}'"))
+    end
+    
+    
+    def named(str)
+      with_name(str).first
+    end
+
+    def condition(cond)
+       search_columns.map{|c| "trim(lower(#{c})) #{cond}"}.join(" or ")
+    end    
+  end  
+end

data/lib/anaf_habtm/string_reader.rb

@@ -0,0 +1,113 @@
+module AnafHabtm
+  class StringReader
+    KEY_SYMPTOM = "*"
+    POSS_SYMPTOM = "-"
+    START_COMMENT = "{"
+    ONE_LINE_COMMENT = "/"
+    END_COMMENT = "}"
+    NEWLINE = "\n"
+    
+    DELIM = [START_COMMENT, NEWLINE, ONE_LINE_COMMENT, END_COMMENT]
+    
+    MULTI_LINE = :multi_line
+    ONE_LINE = :one_line
+    NAME = :name
+    COMMENT = [MULTI_LINE, ONE_LINE]
+    
+    @item = ""
+    @comment = nil
+    @items = []
+    
+    def save(block)
+      unless @item.strip.empty?
+        @items << block.call(@item.strip, @comment.nil? ? nil : @comment.strip)
+      end
+      @item = ""
+      @comment = nil
+    end
+    
+    def write_items(coll, &block)
+      lines = []
+      coll.each do |obj|
+        item, comment = block.call(obj)
+        if comment.nil? || comment.empty?
+          lines << item
+        elsif comment.index("/") || comment.index("\n")
+          lines << "#{item} {#{comment}}"
+        else
+          lines << "#{item} / #{comment}"
+        end
+      end
+      lines.join("\n")
+    end
+    
+    def read_items(str, &block)    
+      @items = []
+      buffer = ""
+      @item = ""
+      @comment = nil
+      state = NAME
+
+      str.chars.each do |char|
+        if (char == "/") && (state != MULTI_LINE)
+          @item = buffer.strip
+          buffer = ""
+          state = ONE_LINE
+        elsif char == "{"
+          @item = buffer.strip
+          buffer = ""
+          state = MULTI_LINE
+        elsif char == "}"
+          @comment = buffer.strip unless buffer.strip.empty?
+          buffer = ""
+          save(block)
+          state = NAME
+        elsif char == "\n"
+          if state == NAME
+            @item = buffer.strip
+            buffer = ""
+            save(block)
+          elsif state == ONE_LINE
+            @comment = buffer.strip
+            state = NAME
+            buffer = ""
+            save(block)
+          else
+            buffer << char
+          end
+        else
+          buffer << char
+        end
+      end
+      
+      if state == ONE_LINE
+        @comment = buffer
+      elsif state == MULTI_LINE
+        @comment = buffer
+      else
+        @item = buffer
+      end
+      save(block)
+      @items
+    end
+    
+    def self.parse_symptom(obj, symptom)
+      if symptom.index(KEY_SYMPTOM) == 0
+        obj.key_symptom = true
+        obj.symptom_name = symptom[KEY_SYMPTOM.length..symptom.length]
+      elsif symptom.index(POSS_SYMPTOM) == 0
+        obj.maybe = true
+        obj.symptom_name = symptom[POSS_SYMPTOM.length..symptom.length]
+      else
+        obj.symptom_name = symptom
+      end
+    end
+    
+    def self.decorate_symptom(obj)
+      decorator = ""
+      decorator = KEY_SYMPTOM if obj.key_symptom
+      decorator = POSS_SYMPTOM if obj.maybe
+      "#{decorator}#{obj.symptom_name}"
+    end
+  end
+end

data/lib/anaf_habtm.rb

@@ -1,6 +1,7 @@
-require 'hash'
-require 'anaf_active_record'
-require 'application_helper_methods'
+require 'anaf_habtm/hash'
+require 'anaf_habtm/anaf_active_record'
+require 'anaf_habtm/application_helper_methods'
+require 'anaf_habtm/string_reader'
 ActiveRecord::Base.extend(AnafHabtm::ActiveRecord)
 ActionView::Base.send :include, AnafHabtm::ApplicationHelperMethods
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: anaf_habtm
 version: !ruby/object:Gem::Version 
-  hash: 187
+  hash: 185
   prerelease: false
   segments: 
   - 0
   - 0
-  - 82
-  version: 0.0.82
+  - 83
+  version: 0.0.83
 platform: ruby
 authors: 
 - Tyler Gannon
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-11 00:00:00 -07:00
+date: 2010-07-12 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -33,12 +33,13 @@ files:
 - Rakefile
 - anaf_habtm.gemspec
 - install.rb
-- lib/anaf_active_record.rb
 - lib/anaf_habtm.rb
-- lib/application_helper_methods.rb
+- lib/anaf_habtm/anaf_active_record.rb
+- lib/anaf_habtm/application_helper_methods.rb
+- lib/anaf_habtm/hash.rb
+- lib/anaf_habtm/string_reader.rb
 - lib/generators/anaf_habtm/anaf_habtm_generator.rb
 - lib/generators/anaf_habtm/assets/nested_attributes.js
-- lib/hash.rb
 - rails/init.rb
 - test/anaf_habtm_test.rb
 - test/test_helper.rb

data/lib/anaf_active_record.rb

@@ -1,44 +0,0 @@
-
-module AnafHabtm
-  module ActiveRecord
-    def anaf_habtm(association, options={}, &block)
-      class_eval do
-        # Define a proc that will look up the (potentially) existing object
-        finder = proc {|id| association.to_s.singularize.camelize.constantize.where(:id=>id).first
-        }
-        
-        # Define a proc that will set the association collection
-        set_collection = proc {|me, coll| me.send("#{association.to_s.tableize}=", coll)}
-        has_and_belongs_to_many association.to_sym, options
-        # Define the actual association setter.
-        define_method "#{association.to_s.tableize}_attributes=", lambda{|attributes_for_association|
-          coll = []
-          
-          attributes_for_association.each_value do |params|
-            next if params["_destroy"] == "1"
-            obj = finder.call(params["id"]) if params.has_key?("id")
-            params.extend(AnafHabtm::HashExtension)
-            # ActiveRecord::Base.attributes=() doesn't like extra parameters.
-            coll << block.call(params.copy_without_destroy, obj)
-          end
-          set_collection.call(self, coll)
-        }
-      end
-    end
-    
-    def named_association(member, attribute, opts={})
-      member = member.to_s
-      klass = opts.has_key?(:class) ? opts[:class_name] : member.to_s.singularize.camelize
-      attribute = attribute.to_s
-      if opts.has_key?(:create)
-        class_eval "def #{member}_#{attribute}=(#{attribute}); 
-        return if #{attribute}.blank?
-        self.#{member} = #{klass}.find_or_create_by_#{attribute}(#{attribute})
-        end;"
-      else
-        class_eval "def #{member}_#{attribute}=(#{attribute}); self.#{member} = #{klass}.find_by_#{attribute}(#{attribute}) unless #{attribute}.blank?; end;"
-      end
-      class_eval "def #{member}_#{attribute}; #{member}.#{attribute} if #{member}; end;"
-    end
-  end  
-end