flatten_record 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f11d8fa55541889fa6fdcce3dbf9ab49a3e80d1
-  data.tar.gz: fe9feffcbd9da172e4922a8b413451e2bedbe8f5
+  metadata.gz: b3f760e4ba28e47a8cb7e46621300db8c99d36c9
+  data.tar.gz: 4129c16a709afbd09567ee9ce888257651f20a19
 SHA512:
-  metadata.gz: cd1c791340df638d6e41d4800a3b0ba838df3b3c07f4b91c0902167e7571401097af71e2962658aa29e4b2666743e80c4be2a7c6377c3d67b7c7c1160d0b84ea
-  data.tar.gz: d7a6093c910fffcd069b442d3f4dc3e494383db65341de9c497fdaf4c6fcc4b3eaab674f9f73c3d218e82daacfd781f33c5d1d63e2b360dd9accd85c35768dba
+  metadata.gz: 5713c428677377b05b1feb93bc50fa821c173e6ccc33a52c6c571e1731c495d372b4f9006920d4ef811686b8d990ee6ef2f513f3efa3a9861e1d88fc71f851ba
+  data.tar.gz: 3ea39337ec9243801d6883bf1831267e3bbb28f70f6bf6af543dd8684e19ea7a4456e9c3c4029e2c507901d43900ba149525f9c94fa2c72e27148c8951a5cf2f

data/lib/flatten_record/definition.rb

@@ -45,21 +45,13 @@ module FlattenRecord
 
     protected   
     def validate_except(attrs)
-      attrs.each do |attr|
-        error = "unknown attribute '#{attr}' in #{@target_model.name.to_s}"
-        @errors << error unless target_method?(attr)
-        @except << attr
-      end
+      validate_attrs(:except, attrs)
     end
     
     def validate_only(attrs)
-      attrs.each do |attr|
-        error = "unknown attribute '#{attr}' in #{@target_model.name.to_s}"
-        @errors << error unless target_method?(attr)
-        @only << attr
-      end
+      validate_attrs(:only, attrs)
     end
-   
+  
     def validate_methods(methods)
       methods.each do |method, type| 
         error = "undefined method '#{method}' in #{@target_model.name}"
@@ -92,6 +84,19 @@ module FlattenRecord
     end
 
     private
+    def validate_attrs(name, attrs)
+      attrs.each do |attr|
+        error = "unknown attribute '#{attr}' in #{@target_model.name.to_s}"
+        @errors << error unless target_method?(attr)
+        case name
+        when :only
+          @only << attr
+        when :except
+          @except << attr
+        end
+      end
+    end
+ 
     def model_method?(method)
       @model.attribute_method?(method) || 
         @model.method_defined?(method) 

data/lib/flatten_record/meta/id_column.rb

@@ -2,8 +2,7 @@ module FlattenRecord
   module Meta
     class IdColumn < Column
       def initialize(parent, primary_key, target_model, model)
-        @column = primary_key
-        super(parent, @column, target_model, model) 
+        super(parent, primary_key, target_model, model) 
       end
 
       def name

data/lib/flatten_record/meta/normalized_attr.rb

@@ -7,12 +7,8 @@ module FlattenRecord
       end
       
       def all_columns
-        return @columns if @columns
-        child_columns = @include.values.collect do |n|
-          n[:columns] + n[:methods] + n[:compute]
-        end
-        child_columns.flatten!
-        @columns = @base_columns + @methods + @compute + child_columns 
+        child_columns = @include.values.collect(&:all_columns)
+        @base_columns + @methods + @compute + child_columns.flatten 
       end
 
       def associated_models
@@ -59,22 +55,27 @@ module FlattenRecord
 
       def build(definition)
         super(definition)
-
+        
+        @foreign_keys = []
         primary_key = target_columns.select(&:primary).first
         @id_column = IdColumn.new(self, primary_key, target_model, model)
-
-        @excluded_columns = []
+        
         @compute = build_compute(definition) || []
         @methods = build_methods(definition) || []
         @include = build_children(definition) || {}
         @base_columns = build_columns(definition) || []
         
-        dups = find_dup_columns
-        if !dups.blank?
-          raise "#{@excluded_columns.inspect}Duplicate columns found: #{dups.join(", ")}"
-        end
+        validate_columns(all_columns)
+
         self
       end
+
+      def validate_columns(columns)
+        dups = find_dup_columns(columns)
+        if dups.present?
+          raise "Duplicate columns found: #{dups.join(", ")}"
+        end
+      end
       
       def children
         (@base_columns + @compute + @methods + @include.values)
@@ -130,38 +131,54 @@ module FlattenRecord
       end
 
       private
-      def find_dup_columns
+      def find_dup_columns(columns)
         dups = []
-        all_columns.each do |column|
-          all_columns.each do |comp|
-            if comp.parent != column.parent && comp.name == column.name
-              parent_target = column.parent.target_model.to_s
-              original_name = column.column.name
-              dups << "#{column.name} was from #{parent_target}'s #{original_name}"
-            end
+        columns.each do |column|
+          if match_columns?(columns, column)
+            parent_target = column.parent.target_model
+            original_name = column.column.name
+            dups << "#{column.name} was from #{parent_target}'s #{original_name}"
           end
         end
         dups
       end
 
-      def associated_node_factory(parent, child, class_name)
-        klass_map = [:has_many, :belongs_to, :has_one]
+      def match_columns?(columns, column)
+        columns.each do |c|
+          if c.parent != column.parent && c.name == column.name
+            return true
+          end
+        end
+        false
+      end
 
+      def associated_node_factory(parent, child, class_name)
         association = target_model.reflect_on_association(child)
-        @excluded_columns << association.foreign_key.to_s
-        
-        class_name ||= association.klass
-        node = nil
+
+        raise_missing_macro(child, target_model) unless association.macro
         
-        if klass_map.include?(association.macro)
-          klass = association.macro.to_s.camelize.to_sym
-          node = Meta.const_get(klass).new(parent, association, class_name, model)
-        elsif associaton.macro.nil?
-          raise "association with '#{child}' on #{target_name} is not found"
+        if association_node?(association.macro)
+          class_name ||= association.klass
+          type = "#{association.macro}"
+          klass = Meta.const_get(type.camelize)
+          
+          @foreign_keys << association.foreign_key.to_s 
+          klass.new(parent, association, class_name, model)
         else
-          raise "association type '#{association.macro}' with '#{child}' is not supported"
+          raise_unsupported_type(association.macro, target_model)
         end
-        node 
+      end
+
+      def association_node?(type)
+        [:has_many, :belongs_to, :has_one].include?(type) 
+      end
+
+      def raise_unsupported_type(type, model)
+        raise "association type '#{type}' with '#{model}' is not supported"
+      end
+
+      def raise_missing_macro(child, model)
+        raise "association with '#{child}' on #{model} is not found"
       end
 
       def columns_from_definition(definition)
@@ -176,7 +193,7 @@ module FlattenRecord
 
       def allow_column?(col, definition)
         return false if col.primary
-        return false if @excluded_columns.include?(col.name.to_s) 
+        return false if @foreign_keys.include?(col.name.to_s) 
 
         if definition[:only].present?
           definition[:only].include?(col.name.to_sym) 

data/lib/flatten_record/version.rb

@@ -1,3 +1,3 @@
 module FlattenRecord
-  VERSION = "1.0.2"
+  VERSION = "1.0.3"
 end

data/lib/generators/flatten_record/migration/migration_generator.rb

@@ -8,49 +8,51 @@ module FlattenRecord
         @source_root ||= File.join(File.dirname(__FILE__), 'templates')
       end
       
-      argument :name, :description => 'path to model'
+      argument :name, :description => 'model'
 
       def generate_files
-        if !valid? 
-          puts(red("Error. #{name.camelize} is not found")) and return
-        end
-
-        defined_classes.each do |class_name|
-          @klass = class_name.constantize
-          @table_name = @klass.table_name
-          @table_columns = denormalized_columns if meta
-
-          case
-          when @klass.table_exists?
-            puts yellow("Warning. Table already exists: #{@table_name}")
-            diff_and_generate if meta 
-          
-          when meta
-            migration_template('migration.erb', "db/migrate/create_table_#{@table_name}.rb")
-          
-          else
-            puts red("Error. No denormalization definition found in #{@table_name}")
-          end
+        return unless valid? 
+
+        @table_name = klass.table_name
+        if klass.table_exists?
+          puts "Table already exists: #{@table_name}"
+          diff_and_generate 
+        else
+          @table_columns = denormalized_columns
+          migration_template('migration.erb', "db/migrate/create_table_#{@table_name}.rb")    
         end
       end
 
       private
       def meta
-        @klass.flattener_meta
+        klass.flattener_meta
       end
-
+ 
       def denormalized_columns
-        @klass.denormalizer_meta.denormalized_columns
+        meta.all_columns
       end
-      
+
+      def klass_name
+        name.camelize
+      end
+
+      def klass
+        klass_name.constantize
+      end
+
+      def table_name
+        klass.table_name
+      end
+
+      def flatten_klass_names
+        FlattenRecord::Config.included_models
+      end
+
       def diff_and_generate
         if any_diff?
-          puts blue("Generating migration based on the difference..") 
-          puts ""
-          puts "      #{green('Add columns:')} #{add_columns_names}" unless add_columns.empty?
-          puts ""
-          puts "      #{red('Drop columns:')} #{drop_columns_names}" unless drop_columns.empty?
-          puts ""
+          puts "Generating migration based on the difference.."
+          puts "  #{green('Add columns:')} #{add_columns_names}" unless add_columns.empty?
+          puts "  #{red('Drop columns:')} #{drop_columns_names}" unless drop_columns.empty?
 
           @migration = add_columns.empty? ? 
             "drop_#{drop_columns.first.name}_etc_from" : 
@@ -60,15 +62,6 @@ module FlattenRecord
         end
       end
 
-      def colorize(text, color_code)
-        "\e[#{color_code}m#{text}\e[0m"
-      end
-
-      def red(text); colorize(text, 31); end
-      def green(text); colorize(text, 32); end
-      def yellow(text); colorize(text, 33); end
-      def blue(text); colorize(text, 34); end
-
       def any_diff?
         !add_columns.empty? || !drop_columns.empty? 
       end
@@ -81,38 +74,59 @@ module FlattenRecord
         drop_columns.collect(&:name).join(', ')
       end
 
-      def add_columns
-        @add_columns ||= denormalized_columns.inject([]) do |cols, col| 
-          cols ||= []
-          @klass.columns.collect(&:name).include?(col.name) ?
-            cols : cols << col
-        end
+      def columns
+        klass.columns
       end
-      
-      def drop_columns
-        @drop_columns ||= @klass.columns.inject([]) do |cols, col|
-          next if col.name == 'id'
-          cols ||= []
-          denormalized_columns.collect(&:name).include?(col.name) ?
-            cols : cols << col
-        end
+
+      def denormalized_column_names
+        denormalized_columns.map(&:name)
       end
 
-      def denormalized_columns
-        meta.all_columns
+      def column_names
+        columns.map(&:name)
       end
 
-      def defined_classes
-        @klass = name.camelize
-        [@klass]
+      def add_columns
+        @add_columns ||= 
+          denormalized_columns.inject([]) do |cols, col|
+            if !column_names.include?(col.name)
+              cols << col
+              puts "#{col.name}"
+            end
+            cols
+          end
+      end
+      
+      def drop_columns
+        @drop_columns ||= 
+          columns.inject([]) do |cols, col|
+            if col.name != 'id' && !denormalized_column_names.include?(col.name)
+              cols << col
+            end
+            cols
+          end
       end
 
       def valid?
         Rails.application.eager_load!
-        @klass = name.camelize
-        @klasses = FlattenRecord::Config.included_models
-        @klasses.include?(@klass.to_s)
+        
+        begin 
+          klass && meta
+        rescue Exception => e
+          puts red(e.message)
+          false
+        end
+      end
+      
+      def colorize(text, color_code)
+        "\e[#{color_code}m#{text}\e[0m"
       end
+
+      def red(text); colorize(text, 31); end
+      def green(text); colorize(text, 32); end
+      def yellow(text); colorize(text, 33); end
+      def blue(text); colorize(text, 34); end
+
     end
   end
 end