to_factory 0.1.1 → 0.2.0

data/.travis.yml

@@ -9,6 +9,7 @@ rvm:
   - 2.1.0
   - 2.0.0
   - 1.9.3
+  - 1.9.2
   - 1.8.7
 
 script: "./bin/ci"

data/README.md

@@ -1,4 +1,4 @@
-ToFactory
+ToFactory :wrench:
 =========
 
 [![Build Status](https://travis-ci.org/markburns/to_factory.svg)](https://travis-ci.org/markburns/to_factory)
@@ -16,11 +16,10 @@ Easily add factories with valid data for an existing project.
 * unintrusively update factory files in place
 * Parses and writes both new `FactoryGirl`, syntax or older `Factory.define` syntax
 
-Tested against Ruby 1.8.7, 1.9.3, 2.0.0,  2.1.x, 2.2.0
+Tested against Ruby 1.8.7, 1.9.2, 1.9.3, 2.0.0,  2.1.x, 2.2.0
 
 
-#Installation
-___________
+## Installation :file_folder:
 
 ```ruby
 
@@ -31,20 +30,21 @@ group :test, :development do
 end
 ```
 
-
-#Warning
+## Warning :warning:
 `ToFactory` writes into the `spec/factories` folder. Whilst it
 is tested and avoids overwriting existing factories,
 it is recommended that you execute after committing or when in a known
 safe state.
 
-#Example
+
+
 ```bash
 git add spec/factories
 git commit -m "I know what I am doing"
 rails c
 >ToFactory()
 ```
+## Example :computer:
 
 ```ruby
 #Generate all factories
@@ -87,10 +87,7 @@ ToFactory :admin => User.last
 
 ```
 
-#Known bugs/limitations
-* Factory generation does not follow a hierarchical order, so factory files may require manual editing for now.
-
-#Other useful projects
+### Other useful projects
 
 If you are adding specs to an existing project you may want to look at:
 

data/lib/to_factory/collation.rb

@@ -2,32 +2,58 @@ module ToFactory
   AlreadyExists = Class.new ArgumentError
 
   class Collation
-    def self.merge(a, b)
-      c = new
+    def self.organize(a,b)
+      new(a, b).organize
+    end
 
-      c.merge_without_collisions(a.with_indifferent_access, b.with_indifferent_access)
+    def self.representations_from(a,b)
+      new(a, b).representations
     end
 
-    def merge_without_collisions(a,b)
-      nested_detect_collisions!(a, b)
+    def initialize(a, b)
+      @a = a
+      @b = b
+    end
 
-      a.deep_merge(b)
+    def organize
+      representations.group_by(&:klass).inject({}) do |o, (klass,r)|
+        o[klass] = r.sort_by(&:hierarchy_order)
+        o
+      end
     end
 
-    def nested_detect_collisions!(a,b)
-      a.each do |a_klass, _|
-        b.each do |b_klass, _|
-          detect_collisions!(a[a_klass] || {}, b[b_klass] || {})
+    def representations
+      detect_collisions!(@a,@b)
+
+      inference = KlassInference.new(merged)
+
+      merged.each do |r|
+        klass, order = inference.infer(r.name)
+        r.klass = klass
+        r.hierarchy_order = order
+      end
+
+      merged
+    end
+
+    def detect_collisions!(a,b)
+      collisions = []
+      a.each do |x|
+        b.each do |y|
+          collisions << x.name if x.name == y.name
         end
       end
+
+      raise_already_exists!(collisions) if collisions.any?
     end
 
-    def detect_collisions!(a, b)
-      overlapping = a.keys & b.keys
-      raise_already_exists!(overlapping) if overlapping.any?
+    private
+
+    def merged
+      @merged ||= @a + @b
     end
 
-    def raise_already_exists!(keys)
+   def raise_already_exists!(keys)
       raise ToFactory::AlreadyExists.new "an item for each of the following keys #{keys} already exists"
     end
   end

data/lib/to_factory/file_sync.rb

@@ -9,22 +9,24 @@ module ToFactory
     end
 
     def perform(exclusions=[])
-      definitions = Collation.merge(new_definitions(exclusions), pre_existing)
-
-      @file_writer.write(definitions)
+      @file_writer.write(all_representations exclusions)
     end
 
-    def new_definitions(exclusions=[])
-      return {} if exclusions == [:all]
+    def all_representations(exclusions=[])
+      Collation.organize(
+        new_representations(exclusions),
+        existing_representations)
+    end
 
+    def new_representations(exclusions=[])
       instances = @model_finder.call(exclusions)
 
-      DefinitionGroup.perform(instances)
+      instances.map{|r| Representation.from(r) }
     end
 
     private
 
-    def pre_existing
+    def existing_representations
       @factory_finder.call
     end
 

data/lib/to_factory/file_writer.rb

@@ -5,33 +5,43 @@ module ToFactory
     end
 
     def write(definitions)
-      definitions.each do |klass, factories|
-        name = klass.name.underscore.gsub /^"|"$/, ""
-        mkdir(name) if name.to_s["/"]
-
-        File.open(File.join(ToFactory.factories, "#{name}.rb"), "w") do |f|
-          f << wrap_factories(factories.values)
+      definitions.each do |klass, representations|
+        write_to(name_from klass) do
+          wrap_factories(representations.map(&:definition))
         end
       end
     end
 
     private
 
-    def wrap_factories(factories)
+    def name_from(klass)
+      klass.name.underscore.gsub /^"|"$/, ""
+    end
+
+    def write_to(name)
+      mkdir(name)
+
+      File.open(File.join(ToFactory.factories, "#{name}.rb"), "w") do |f|
+        f << yield
+      end
+    end
+
+    def wrap_factories(definitions)
       if ToFactory.new_syntax?
-        modern_header(factories)
+        modern_header(definitions)
       else
-        factories.join("\n\n")
+        definitions.join("\n\n")
       end
     end
 
-    def modern_header(factories)
+    def modern_header(definitions)
       out = "FactoryGirl.define do\n"
-      out << factories.join("\n")
+      out << definitions.join("\n")
       out << "\nend\n"
     end
 
     def mkdir(name)
+      return unless name.to_s["/"]
       dir = name.to_s.split("/")[0..-2]
       FileUtils.mkdir_p File.join(ToFactory.factories, dir)
     end

data/lib/to_factory/finders/factory.rb

@@ -2,15 +2,21 @@ module ToFactory
   module Finders
     class Factory
       def call
-        all_factories = {}
+        all = []
 
-        Dir.glob(File.join(ToFactory.factories, "**/*.rb")).each do |f|
-          factories = ToFactory::Parsing::File.parse(f)
-
-          all_factories = Collation.merge(all_factories, factories)
+        parsed_files.each do |r|
+          all = Collation.representations_from(all, r)
         end
 
-        all_factories
+        all
+      end
+
+      private
+
+      def parsed_files
+        Dir.glob(File.join(ToFactory.factories, "**/*.rb")).map do |f|
+          ToFactory::Parsing::File.parse(f)
+        end
       end
     end
   end

data/lib/to_factory/finders/model.rb

@@ -4,15 +4,9 @@ module ToFactory
       def call(exclusions=[])
         instances = []
 
-        Dir.glob("#{ToFactory.models}/**/*.rb").each do |file|
-          File.readlines(file).each do |f|
-            if match = f.match(/class (.*) ?</)
-              klass = rescuing_require file, match
-              break if exclusions.include?(klass)
-              instance = get_active_record_instance(klass)
-              instances << instance if instance
-              break
-            end
+        each_klass(exclusions) do |klass|
+          if instance = get_active_record_instance(klass)
+            instances << instance
           end
         end
 
@@ -21,6 +15,28 @@ module ToFactory
 
       private
 
+      def each_klass(exclusions)
+        models.each do |file|
+          matching_lines(file) do |match|
+            klass = rescuing_require(file, match)
+
+            break if exclusions.include?(klass) || yield(klass)
+          end
+        end
+      end
+
+      def models
+        Dir.glob("#{ToFactory.models}/**/*.rb")
+      end
+
+      def matching_lines(file)
+        File.readlines(file).each do |l|
+          if match = l.match(/class (.*) ?</)
+            yield match
+          end
+        end
+      end
+
       def rescuing_require(file, match)
         require file
         klass = eval(match[1])

data/lib/to_factory/generation/attribute.rb

@@ -17,35 +17,53 @@ module ToFactory
       end
 
       def inspect_value(value, nested=false)
-        formatted = case value
+        formatted = format(value, nested)
+
+        if !value.is_a?(Hash) && !nested
+          formatted = " #{formatted}"
+        end
+
+        formatted
+      end
+
+      private
+
+      def format(value, nested)
+        case value
         when Time, DateTime
-          time = in_utc(value).strftime("%Y-%m-%dT%H:%M%Z").inspect
-          time.gsub(/UTC"$/, "Z\"").gsub(/GMT"$/, "Z\"")
+          inspect_time(value)
         when BigDecimal
           value.to_f.inspect
         when Hash
-          formatted = value.keys.inject([]) do |a, key|
-            formatted_key = inspect_value(key, true)
-            formatted_value = inspect_value(value.fetch(key), true)
-            a << "#{formatted_key} => #{formatted_value}"
-          end.join(', ')
-
-          if nested
-            "{#{formatted}}"
-          else
-            "({#{formatted}})"
-          end
+          inspect_hash(value, nested)
         when Array
           value.map{|v| inspect_value(v)}
         else
           value.inspect
         end
+      end
 
-        if !value.is_a?(Hash) && !nested
-          formatted = " #{formatted}"
+      def inspect_time(value)
+        time = in_utc(value).strftime("%Y-%m-%dT%H:%M%Z").inspect
+        time.gsub(/UTC"$/, "Z\"").gsub(/GMT"$/, "Z\"")
+      end
+
+      def inspect_hash(value, nested)
+        formatted = value.keys.inject([]) do |a, key|
+          a << key_value_pair(key, value)
+        end.join(', ')
+
+        if nested
+          "{#{formatted}}"
+        else
+          "({#{formatted}})"
         end
+      end
 
-        formatted
+      def key_value_pair(key, value)
+        formatted_key = inspect_value(key, true)
+        formatted_value = inspect_value(value.fetch(key), true)
+        "#{formatted_key} => #{formatted_value}"
       end
 
       def in_utc(time)

data/lib/to_factory/generation/factory.rb

@@ -1,42 +1,36 @@
 module ToFactory
   module Generation
     class Factory
-      def initialize(object, name)
-        unless object.is_a? ActiveRecord::Base
-          message = "Generation::Factory requires initializing with an ActiveRecord::Base instance"
-          message << "\n  but received #{object.inspect}"
-          raise ToFactory::MissingActiveRecordInstanceException.new(message)
-        end
-
-        @name = add_quotes name
-        @attributes = object.attributes
+      def initialize(representation)
+        @representation = representation
       end
 
-      def to_factory(parent_name=nil)
-        header(parent_name) do
-          to_skip = [:id, :created_at, :updated_at]
-          attributes = @attributes.delete_if{|key, _| to_skip.include? key.to_sym}
+      def name
+        add_quotes @representation.name
+      end
 
+      def to_factory
+        header do
           attributes.map do |attr, value|
             factory_attribute(attr, value)
           end.sort.join("\n") << "\n"
         end
       end
 
-      def header(parent_name=nil, &block)
+      def header(&block)
         if ToFactory.new_syntax?
-          modern_header parent_name, &block
+          modern_header &block
         else
-          header_factory_girl_1 parent_name, &block
+          header_factory_girl_1 &block
         end
       end
 
-      def modern_header(parent_name=nil, &block)
-        generic_header(parent_name, "factory", "", &block)
+      def modern_header(&block)
+        generic_header("factory", "", &block)
       end
 
-      def header_factory_girl_1(parent_name=nil, &block)
-        generic_header(parent_name, "Factory.define", "|o|", &block)
+      def header_factory_girl_1(&block)
+        generic_header("Factory.define", " |o|", &block)
       end
 
       def factory_attribute(attr, value)
@@ -45,14 +39,28 @@ module ToFactory
 
       private
 
-      def generic_header(parent_name, factory_start, block_arg, &block)
-        out =  "  #{factory_start}(:#{@name}#{parent_clause(parent_name)}) do#{block_arg}\n"
+      def attributes
+        to_skip = [:id, :created_at, :updated_at]
+
+        @representation.attributes.delete_if{|key, _| to_skip.include? key.to_sym}
+      end
+
+      def parent_name
+        @representation.parent_name
+      end
+
+      def generic_header(factory_start, block_arg, &block)
+        out =  "  #{factory_start}(:#{name}#{parent_clause}) do#{block_arg}\n"
         out << yield.to_s
         out << "  end\n"
       end
 
-      def parent_clause(name)
-        name ?  ", :parent => :#{add_quotes name}" : ""
+      def parent_clause
+        has_parent? ?  ", :parent => :#{add_quotes parent_name}" : ""
+      end
+
+      def has_parent?
+        parent_name.to_s.length > 0
       end
 
       def add_quotes(name)

data/lib/to_factory/klass_inference.rb

@@ -0,0 +1,50 @@
+module ToFactory
+  class CannotInferClass < ArgumentError
+    def initialize(message)
+      super message.inspect
+    end
+  end
+
+  class KlassInference
+    def initialize(representations)
+      @mapping = {}
+
+      representations.each do |r|
+        set_mapping_from(r)
+      end
+    end
+
+    def infer(factory_name, count=0)
+      count = count + 1
+      result  = @mapping[factory_name]
+      return [result, count] if result.is_a? Class
+
+      if result.nil?
+        raise CannotInferClass.new(factory_name)
+      end
+
+      infer(result, count)
+    end
+
+    private
+
+    def set_mapping_from(r)
+      if parent_klass = to_const(r.parent_name)
+        @mapping[r.parent_name] = parent_klass
+      end
+
+      @mapping[r.name] =
+        if factory_klass = to_const(r.name)
+          factory_klass
+        else
+          r.parent_name
+        end
+    end
+
+    def to_const(factory_name)
+      factory_name.to_s.camelize.constantize
+    rescue NameError
+      nil
+    end
+  end
+end

data/lib/to_factory/options_parser.rb

@@ -0,0 +1,34 @@
+module ToFactory
+  class OptionsParser
+    def initialize(options)
+      @options = options
+    end
+
+    def get_instance
+      args = case @options
+      when ActiveRecord::Base
+        from_record(@options)
+      when Array
+        from_array(*@options)
+      end
+
+      Representation.new(*args)
+    end
+
+    def from_record(record)
+      name = calculate_name record.class
+
+      [name, nil, nil, record]
+    end
+
+    def from_array(name, record)
+      parent_name = calculate_name(record.class)
+      parent_name = nil if parent_name.to_s == name.to_s
+      [name, parent_name, nil, record]
+    end
+
+    def calculate_name(klass)
+      klass.name.to_s.underscore
+    end
+  end
+end

data/lib/to_factory/parsing/file.rb

@@ -8,6 +8,7 @@ module ToFactory
   module Parsing
     class File
       delegate :multiple_factories?, :header?, :parse, :to => :parser
+      attr_reader :contents
 
       def self.parse(filename)
         from_file(filename).parse

data/lib/to_factory/parsing/syntax.rb

@@ -1,7 +1,7 @@
-require "to_factory/parsing/klass_inference"
-
 module ToFactory
   module Parsing
+    ParseException = Class.new ::Exception
+
     class Syntax
       attr_accessor :contents
 
@@ -14,17 +14,12 @@ module ToFactory
       end
 
       def parse
-        result = {}
-        @klass_inference = KlassInference.new
-        @klass_inference.setup(all_factories)
-
-        all_factories.each do |factory_name, parent_name, ruby|
-          klass = @klass_inference.infer(factory_name)
-          result[klass] ||= {}
-          result[klass][factory_name] = ruby
+        factories.map do |x|
+          Representation.new(name_from(x), parent_from(x), to_ruby(x))
         end
 
-        result
+      rescue Racc::ParseError, StringScanner::Error => e
+        raise ParseException.new("Original exception: #{e.message}\n #{e.backtrace}\nToFactory Error parsing \n#{@contents}\n o")
       end
 
       def factories
@@ -39,12 +34,6 @@ module ToFactory
         header? ?  sexp[3] : sexp
       end
 
-      def all_factories
-        factories.map do |x|
-          [name_from(x), parent_from(x), to_ruby(x)]
-        end
-      end
-
       def name_from(sexp)
         sexp[1][3][1]
       end

data/lib/to_factory/representation.rb

@@ -0,0 +1,27 @@
+module ToFactory
+  class Representation
+    delegate :attributes, :to => :record
+    attr_accessor :klass, :name, :parent_name, :definition, :hierarchy_order, :record
+
+    def self.from(options)
+      OptionsParser.new(options).get_instance
+    end
+
+    def initialize(name, parent_name, definition=nil, record=nil)
+      @name, @parent_name, @definition, @record =
+        name.to_s, parent_name.to_s, definition, record
+    end
+
+    def inspect
+      "#<ToFactory::Representation:#{object_id} @name: #{@name.inspect}, @parent_name: #{@parent_name.inspect}, @klass: #{klass_name_inspect}>"
+    end
+
+    def klass_name_inspect
+      @klass.name.inspect rescue "nil"
+    end
+
+    def definition
+      @definition ||= ToFactory::Generation::Factory.new(self).to_factory
+    end
+  end
+end

data/lib/to_factory/version.rb

@@ -1,3 +1,3 @@
 module ToFactory
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/to_factory.rb

@@ -1,5 +1,3 @@
-require "deep_merge"
-
 require "to_factory/version"
 require "to_factory/config"
 require "to_factory/generation/factory"
@@ -8,9 +6,11 @@ require "to_factory/collation"
 require "to_factory/file_writer"
 require "to_factory/finders/model"
 require "to_factory/finders/factory"
-require "to_factory/definition_group"
+require "to_factory/representation"
 require "to_factory/file_sync"
 require "to_factory/parsing/file"
+require "to_factory/klass_inference"
+require "to_factory/options_parser"
 
 module ToFactory
   class MissingActiveRecordInstanceException < Exception;end
@@ -29,7 +29,7 @@ module ToFactory
 
     def definitions
       results = Finders::Factory.new.call
-      results.map{|_, r| r.keys}.flatten
+      results.map(&:name)
     end
   end
 end

data/spec/example_factories/new_syntax/user_admin_root.rb

@@ -0,0 +1,21 @@
+FactoryGirl.define do
+  factory(:"to_factory/user") do
+    name("User")
+  end
+
+  factory(:root, :parent => :"to_factory/user") do
+    birthday "2014-07-08T15:30Z"
+    email "test@example.com"
+    name "Jeff"
+    some_attributes({:a => 1})
+    some_id 8
+  end
+
+  factory(:admin, :parent => :"to_factory/user") do
+    name("Admin")
+  end
+
+  factory(:super_admin, :parent => :admin) do
+    name("Super Admin")
+  end
+end