separatum 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b772e3f0272e01367a9e4e8ab1be143964046207677841d6b0532262d6e8a7c1
-  data.tar.gz: 824578f149e375bbc57bb28cf6b44155610a53c7448c5e27b4e09646d625b951
+  metadata.gz: 8e83b3b6b180d0cd4bef68738072cfd4c3ba180e5433bee78c2399c51a2e1894
+  data.tar.gz: fdce513260bcd76e4fd58edbe7ea9676206fa065b10e054124b2fd6eca9763b9
 SHA512:
-  metadata.gz: 92051fcf37e11b151718a21281a95cc23a6cda366a4891623182ba2f3e183e720ebff0758d48960169ff74c0a2e682c1381d581a49f7c3a5561deaa7a2d32325
-  data.tar.gz: 457a164b48dcf7b0b6f30bb5d29e55e24784b7257f2d3d448f611f59a2ce16674f84481bda7d93d4e6d4baadeb3a790a7802937e880fd8af7a4bf6e6afdf1ba4
+  metadata.gz: 69aebdd7d04d72853c639205f0f130a5664a7f953d284917d23808a5861221c39f5d09615eefff13cc95c0ae7b71a7a8bbf74944ea75f2c6980c3f50c96d1432
+  data.tar.gz: 10a9dba816fbb93879e671d783b6a2d3df11e6ce2ce1536046e0960955af61bdfa2f1b330148ff84c622d215142380702ff10dc1ab84abcd4acaa46bee87cf0b

data/.gitignore

@@ -12,4 +12,3 @@
 
 # rspec failure tracking
 .rspec_status
-

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    separatum (0.1.0)
+    separatum (0.1.1)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -4,7 +4,7 @@ Extract and transfer linked objects from one database into another.
 
 ## How you can use it
 
-- Making seeds.rb as copy of production data for testing purposes.
+- Making seeds.rb as copy of production data for testing purposes
 - Making separate database for AB-testing (performance or marketing purposes)
 - Checking your data logical structure (it will raise on broken or unexisting links)
 
@@ -30,8 +30,7 @@ Build new exporter
 
 ```ruby
 exporter = Separatum.build do
-  use Separatum::Importers::ActiveRecord  # We are going to crawl ActiveRecord objects
-  use Separatum::Converters::Object2Hash  # Most of the modules in Separatum is working with Hash-form of objects
+  use Separatum::Importers::ActiveRecord  # We are going to crawl ActiveRecord objects  
   use Separatum::Processors::UuidChanger  # Hide production's UUIDs with no broken links 
   use Separatum::Exporters::JsonFile, file_name: 'separate.json' # Export object to json file                                      
 end
@@ -50,8 +49,7 @@ Build new importer
 
 ```ruby
 importer = Separatum.build do
-  use Separatum::Importers::JsonFile, file_name: 'separate.json' # We are going to import hashed objects from separate.json
-  use Separatum::Converters::Hash2Object # Convert back to real objects (not persisted)
+  use Separatum::Importers::JsonFile, file_name: 'separate.json' # We are going to import hashed objects from separate.json  
   use Separatum::Exporters::ActiveRecord # Save them (in one transaction for all objects in set)
 end
 ```
@@ -67,9 +65,7 @@ importer.() # It returns set of persisted objects
 ```ruby
 seeds_generator = Separatum.build do
   use Separatum::Importers::ActiveRecord
-  use Separatum::Converters::Object2Hash
-  use Separatum::Processors::UuidChanger
-  use Separatum::Converters::Hash2Object
+  use Separatum::Processors::UuidChanger  
   use Separatum::Exporters::ActiveRecordCode
 end
 
@@ -82,9 +78,53 @@ start_object = User.find('any_uuid_you_want_to_start_from')
 puts seeds_generator.(start_object)
 ```
 
+## Building parts
+
+### Separatum::Importers::ActiveRecord
+
+Parameters:
+
+  - max_depth (default: 3)
+  - edge_classes
+  - denied_classes 
+  - denied_class_transitions
+  - svg_file_name
+  - dot_file_name
+
+### Separatum::Importers::JsonFile
+
+Parameters:
+
+  - file_name
+  
+### Separatum::Processors::FieldChanger
+
+Parameters:
+
+  - 1st/2nd - class and field to change
+  - 3rd/4th - class and method that will make transformation 
+  - 3rd  - Proc or Block 
+  
+### Separatum::Exporters::ActiveRecord
+
+### Separatum::Exporters::ActiveRecordCode
+
+Parameters:
+
+  - file_name
+  - ignore_not_unique_classes
+  
+  
+### Separatum::Exporters::JsonFile
+
+Parameters:
+  
+  - file_name
+  - pretty_print
+
 ## TODO
 
-- Data obfuscation (respecting to private data)
+- Timemachine for DateTime fields
 
 ## Development
 

data/lib/separatum/converters/hash2_object.rb

@@ -2,14 +2,15 @@ module Separatum
   module Converters
     class Hash2Object
       def call(*hashes)
-        hashes.map do |hash|
+        hashes.flatten.map do |hash|
           hash_copy = hash.symbolize_keys
-          _klass = hash_copy.delete(:_klass).constantize
-          instance = _klass.new
-          hash_copy.symbolize_keys.each do |k, v|
-            instance.send("#{k}=", v)
+          klass = Object.const_get(hash_copy.delete(:_klass))
+          hash_copy.keys.map(&:to_s).select { |k| '_' == k[0] }.each { |k| hash_copy.delete(k.to_sym) }
+          object = klass.new
+          hash_copy.each do |k, v|
+            object.send("#{k}=", v)
           end
-          instance
+          object
         end
       end
     end

data/lib/separatum/converters/object2_hash.rb

@@ -1,18 +1,24 @@
 module Separatum
   module Converters
     class Object2Hash
+      def initialize(**params)
+        @common_fields = params[:common_fields] || {}
+      end
+
       def call(*objects)
-        objects.map do |object|
+        objects.flatten.map do |object|
+          hash =
+            if object.respond_to?(:as_json)
+              object.as_json
+            elsif object.respond_to?(:to_hash)
+              object.to_hash
+            elsif object.respond_to?(:to_h)
+              object.to_h
+            else
+              fail
+            end
           klass = object.class.respond_to?(:name) ? object.class.name : object.class.to_s
-          if object.respond_to?(:as_json)
-            { _klass: klass }.merge(object.as_json)
-          elsif object.respond_to?(:to_hash)
-            { _klass: klass }.merge(object.to_hash)
-          elsif object.respond_to?(:to_h)
-            { _klass: klass }.merge(object.to_h)
-          else
-            fail(object.inspect)
-          end
+          hash.symbolize_keys.merge(_klass: klass).merge(@common_fields)
         end
       end
     end

data/lib/separatum/core_ext.rb

@@ -0,0 +1,15 @@
+unless Hash.new.respond_to?(:symbolize_keys)
+  class Hash
+    def symbolize_keys
+      Hash[self.map { |(k, v)| [k.to_sym, v] }]
+    end
+  end
+end
+
+unless String.new.respond_to?(:is_uuid?)
+  class String
+    def is_uuid?
+      !!self.match(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/)
+    end
+  end
+end

data/lib/separatum/exporters/active_record.rb

@@ -1,7 +1,8 @@
 module Separatum
   module Exporters
     class ActiveRecord
-      def call(*objects)
+      def call(*hashes)
+        objects = ::Separatum::Converters::Hash2Object.new.(hashes.flatten)
         ::ActiveRecord::Base.transaction do
           objects.each do |o|
             o.class.connection.execute("ALTER TABLE %s DISABLE TRIGGER ALL;" % [o.class.table_name])

data/lib/separatum/exporters/active_record_code/object.rb.erb

@@ -1,3 +1,5 @@
-<%= object.class %>.connection.execute("ALTER TABLE <%= object.class.table_name %> DISABLE TRIGGER ALL;")
-<%= object.class %>.new(<%= attributes_str.join(', ') %>).save!(validate: false)
-<%= object.class %>.connection.execute("ALTER TABLE <%= object.class.table_name %> ENABLE TRIGGER ALL;")
+<% if ignore_not_unique_classes.include?(object.class) %>
+without_triggers(:<%= object.class.table_name %>) { ignore_record_not_unique { <%= object.class %>.new(<%= attributes_str.join(', ') %>).save!(validate: false) } }
+<% else %>
+without_triggers(:<%= object.class.table_name %>) { <%= object.class %>.new(<%= attributes_str.join(', ') %>).save!(validate: false) }
+<% end %>

data/lib/separatum/exporters/active_record_code/program.rb.erb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require File.expand_path('../config/environment', __FILE__)
+
+def without_triggers(table_name, &block)
+  Transactions::CardPayTransaction.connection.execute("ALTER TABLE #{table_name} DISABLE TRIGGER ALL;")
+  yield
+  Transactions::CardPayTransaction.connection.execute("ALTER TABLE #{table_name} ENABLE TRIGGER ALL;")
+end
+
+def ignore_record_not_unique(&block)
+  begin
+    yield
+  rescue ActiveRecord::RecordNotUnique
+    nil
+  end
+end
+
+<%= transactions_str.join("\n") %>

data/lib/separatum/exporters/active_record_code/transaction.rb.erb

@@ -1,3 +1,3 @@
-::ActiveRecord::Base.transaction do
+::ActiveRecord::Base.transaction(joinable: false, requires_new: true) do
 <%= objects_str.join("\n") %>
 end

data/lib/separatum/exporters/active_record_code.rb

@@ -1,26 +1,48 @@
 module Separatum
   module Exporters
     class ActiveRecordCode
+      attr_reader :transactions_str, :objects_str, :attributes_str, :key_str, :value_str, :ignore_not_unique_classes
+
       T_TRANSACTION = File.expand_path(File.join(__FILE__, %w(.. active_record_code transaction.rb.erb)))
       T_OBJECT = File.expand_path(File.join(__FILE__, %w(.. active_record_code object.rb.erb)))
       T_ATTRIBUTE = File.expand_path(File.join(__FILE__, %w(.. active_record_code attribute.rb.erb)))
+      T_PROGRAM = File.expand_path(File.join(__FILE__, %w(.. active_record_code program.rb.erb)))
 
-      attr_reader :objects_str, :attributes_str, :key_str, :value_str
+      def initialize(**params)
+        @file_name = params[:file_name]
+        @ignore_not_unique_classes = params[:ignore_not_unique_classes] || []
+      end
 
-      def call(*objects)
+      def call(*hashes)
+        objects = ::Separatum::Converters::Hash2Object.new.(hashes.flatten)
         @objects_str = objects.map do |object|
           @attributes_str = object.attributes.map do |key, value|
             @key_str = key
-            if value.is_a?(ActiveSupport::TimeWithZone)
-              @value_str = "\"#{value}\""
-            else
-              @value_str = value.inspect
-            end
+            @value_str = value_to_code(value)
             ERB.new(File.read(T_ATTRIBUTE)).result(binding).strip
           end
           ERB.new(File.read(T_OBJECT)).result(binding).strip
         end
-        ERB.new(File.read(T_TRANSACTION)).result(binding).strip
+        @transactions_str = [ERB.new(File.read(T_TRANSACTION)).result(binding).strip]
+        script = ERB.new(File.read(T_PROGRAM)).result(binding).strip
+
+        if @file_name
+          File.write(@file_name, script)
+        end
+
+        script
+      end
+
+      def value_to_code(value)
+        if defined?(ActiveSupport::TimeWithZone) && value.is_a?(ActiveSupport::TimeWithZone)
+          value.to_s.dump
+        elsif defined?(Date) && value.is_a?(Date)
+          value.to_s.dump
+        elsif value.is_a?(String)
+          value.dump
+        else
+          value.inspect
+        end
       end
     end
   end

data/lib/separatum/exporters/json_file.rb

@@ -6,10 +6,11 @@ module Separatum
         @pretty_print = pretty_print
       end
 
-      def call(*array)
-        str = @pretty_print ? JSON.pretty_generate(array) : JSON.dump(array)
+      def call(*hashes)
+        hashes.flatten!
+        str = @pretty_print ? JSON.pretty_generate(hashes) : JSON.dump(hashes)
         File.write(@file_name, str)
-        array
+        hashes
       end
     end
   end

data/lib/separatum/graph_viz/drawer.rb

@@ -0,0 +1,37 @@
+module Separatum
+  module GraphViz
+    class Drawer
+      def initialize(svg_file_name: nil, dot_file_name: nil)
+        @svg_file_name = svg_file_name
+        @dot_file_name = dot_file_name
+        @gvp = ::Separatum::GraphViz::Proxy.new(::GraphViz.new(:G, type: :digraph))
+      end
+
+      def draw(object_transitions)
+        object_transitions.each do |prev_object, next_object|
+          prev_node = @gvp.add_node(object_title(prev_object))
+          next_node = @gvp.add_node(object_title(next_object))
+          @gvp.add_edge(prev_node, next_node)
+        end
+
+        if @svg_file_name
+          @gvp.output(svg: @svg_file_name)
+        end
+
+        if @dot_file_name
+          @gvp.output(dot: @dot_file_name)
+        end
+
+        self
+      end
+
+      def object_title(object)
+        if object.id.is_a?(String) && object.id.is_uuid?
+          "#{object.class}[#{object.id.slice(0, 6)}]"
+        else
+          "#{object.class}[#{object.id}]"
+        end
+      end
+    end
+  end
+end

data/lib/separatum/graph_viz/proxy.rb

@@ -0,0 +1,30 @@
+module Separatum
+  module GraphViz
+    class Proxy
+      attr_reader :gv
+
+      def initialize(gv)
+        @gv = gv
+        @gv[:overlap] = :false
+        @nodes = {}
+      end
+
+      def add_node(name, *options)
+        if @nodes.key?(name)
+          @nodes[name]
+        else
+          @nodes[name] = @gv.add_node(name, *options)
+        end
+      end
+
+      def add_edge(node1, node2)
+        @gv.add_edges(node1, node2)
+      end
+
+      # FIXME: change to delegate/forwardable
+      def output(*params)
+        @gv.output(*params)
+      end
+    end
+  end
+end

data/lib/separatum/importers/active_record.rb

@@ -6,81 +6,92 @@ module Separatum
       attr_reader :klass_transitions, :object_transitions
 
       def initialize(**params)
-        @max_depth = params[:max_depth] || 2
-        @skip_through = params[:skip_through] || true
-        @skip_nil = params[:skip_nil] || true
+        @max_depth = params[:max_depth] || 3
+        @edge_classes = params[:edge_classes] || []
+        @denied_classes = params[:denied_classes] || []
+        @denied_class_transitions = params[:denied_class_transitions] || []
 
-        @skip_klasses = params[:skip_klasses] || []
-        @skip_objects = params[:skip_objects] || []
-        @skip_klass_transitions = params[:skip_klass_transitions] || []
-        @skip_object_transitions = params[:skip_object_transitions] || []
+        @svg_file_name = params[:svg_file_name]
+        @dot_file_name = params[:dot_file_name]
 
         @klass_transitions = Set[]
         @object_transitions = Set[]
         @objects = Set[]
       end
 
-      def call(object)
-        @objects.add(object)
-        act(object)
-        @objects.to_a
+      def call(*objects)
+        result = []
+        objects.flatten.each do |object|
+          @objects = Set[object]
+          act(object)
+          result += @objects.to_a
+        end
+
+        if @svg_file_name || @dot_file_name
+          if defined? ::GraphViz
+            ::Separatum::GraphViz::Drawer.new(svg_file_name: @svg_file_name, dot_file_name: @dot_file_name).draw(@object_transitions)
+          else
+            fail("GraphViz const is undefined. Use ruby-graphviz gem")
+          end
+        end
+
+        ::Separatum::Converters::Object2Hash.new.(result.flatten.uniq)
       end
 
       def act(object, depth = 1)
         object.class.reflections.each do |association_name, reflection|
-          if @skip_through && reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
-            next
-          end
+          # Skip Through associations
+          next if reflection.is_a?(::ActiveRecord::Reflection::ThroughReflection)
 
-          if @skip_nil && object.send(association_name).nil?
-            next
-          end
+          # Skip empty associations
+          next if object.send(association_name).nil?
 
-          if depth >= @max_depth
-            next
-          end
+          # Limit depth
+          next if depth >= @max_depth
 
           case reflection.macro
           when :belongs_to, :has_one
-            new_object = object.send(association_name)
-            next if @objects.include?(new_object)
-            next if new_object.is_one_of_a?(@skip_klasses)
-
-            next if @object_transitions.include?([new_object, object])
-            next if @skip_objects.include?(new_object)
-            next if @skip_object_transitions.include?([object, new_object])
-            next if @skip_klasses.include?(new_object.class)
-            next if @skip_klass_transitions.include?([object.class, new_object.class])
+            next_object = object.send(association_name)
+            next unless process_link(object, next_object)
+            puts "#{depth}#{' ' * depth}[#{reflection.macro}] #{object.class} -> #{next_object.class}"
+            act(next_object, depth + 1)
 
-            @objects.add(new_object)
-            @klass_transitions.add([object.class, new_object.class])
-            @object_transitions.add([object, new_object])
-            act(new_object, depth + 1)
-
-
-          when :has_many
+          when :has_many, :has_and_belongs_to_many
             new_objects = object.send(association_name)
-            new_objects.each do |new_object|
-              next if @objects.include?(new_object)
-              next if new_object.is_one_of_a?(@skip_klasses)
-
-              next if @object_transitions.include?([new_object, object])
-              next if @skip_objects.include?(new_object)
-              next if @skip_object_transitions.include?([object, new_object])
-              next if @skip_klasses.include?(new_object.class)
-              next if @skip_klass_transitions.include?([object.class, new_object.class])
-
-              @objects.add(new_object)
-              @klass_transitions.add([object.class, new_object.class])
-              @object_transitions.add([object, new_object])
-              act(new_object, depth + 1)
+            new_objects.each do |next_object|
+              next unless process_link(object, next_object)
+              puts "#{depth}#{' ' * depth}[#{reflection.macro}] #{object.class} -> #{next_object.class}"
+              act(next_object, depth + 1)
             end
 
           else
-            fail
+            fail("Unknown association `#{reflection.macro.inspect} :#{association_name}' in #{object.class}")
           end
         end
       end
+
+      def process_link(prev_object, next_object)
+        # Skip already added object
+        return if @objects.include?(next_object)
+
+        # Skip already processed link
+        return if @object_transitions.include?([prev_object, next_object])
+
+        # Stuck on edge classes
+        return if @edge_classes.include?(prev_object.class)
+
+        # Will not go to denied classes
+        return if @denied_classes.include?(next_object.class)
+
+        # Will not go through denied transitions
+        return if @denied_class_transitions.include?([prev_object.class, next_object.class])
+
+        @objects.add(next_object)
+        @klass_transitions.add([prev_object.class, next_object.class])
+        @object_transitions.add([prev_object, next_object])
+
+        true
+      end
     end
   end
 end

data/lib/separatum/importers/json_file.rb

@@ -5,9 +5,10 @@ module Separatum
         @file_name = file_name
       end
 
-      def call(*_)
+      def call(*)
         str = File.read(@file_name)
-        JSON.parse(str)
+        hash = JSON.parse(str)
+        hash.symbolize_keys
       end
     end
   end

data/lib/separatum/processors/field_changer.rb

@@ -0,0 +1,64 @@
+module Separatum
+  module Processors
+    class FieldChanger
+      # Allows:
+      #   SomeClass#method
+      #   SomeNamespace::SomeClass#method
+      #   SuperNamespace::SomeNamespace::SomeClass#method
+      CLASS_METHOD = /^([A-Za-z_][0-9A-Za-z_]*(?:::[A-Za-z_][0-9A-Za-z_]*)*)#([A-Za-z_][0-9A-Za-z_]*)$/
+
+      def initialize(*options, &block)
+        parse_options(*options, &block)
+      end
+
+      def call(*hashes)
+        hashes.flatten.map do |hash|
+          new_hash = hash.symbolize_keys
+          if hash[:_klass] == @klass && hash.key?(@method)
+            new_hash[@method] = @transformer.call(hash[@method])
+          end
+          new_hash
+        end
+      end
+
+      def parse_options(*options)
+        p1 = options.shift
+        if p1.is_a?(String) && (res = p1.match(CLASS_METHOD))
+          @klass = res[1]
+          @method = res[2].to_sym
+        elsif p1.is_a?(Class)
+          @klass = p1.to_s
+          p2 = options.shift
+          if p2.is_a?(Symbol)
+            @method = p2
+          else
+            fail
+          end
+        else
+          fail
+        end
+
+        if block_given?
+          @transformer = Proc.new
+          pp @transformer
+        else
+          p3 = options.shift
+          if p3.is_a?(Proc)
+            @transformer = p3
+          elsif p3.is_a?(String) && (res = p3.match(CLASS_METHOD))
+            @transformer = Proc.new { |value| Object.const_get(res[1]).new.send(res[2].to_sym, value) }
+          elsif p3.is_a?(Class)
+            p4 = options.shift
+            if p4.is_a?(Symbol)
+              @transformer = Proc.new { |value| p3.new.send(p4, value) }
+            else
+              fail
+            end
+          else
+            fail
+          end
+        end
+      end
+    end
+  end
+end

data/lib/separatum/processors/inspect.rb

@@ -2,7 +2,7 @@ module Separatum
   module Processors
     class Inspect
       def call(*array)
-        array.each { |o| puts "#{o.inspect}" }
+        array.flatten.each { |o| puts "#{o.inspect}" }
         array
       end
     end

data/lib/separatum/processors/uuid_changer.rb

@@ -3,18 +3,30 @@ require 'securerandom'
 module Separatum
   module Processors
     class UuidChanger
-      def initialize
+      def initialize(**params)
+        @skip_classes = (params[:skip_classes] || []).map(&:to_s)
+        @skip_classes_uuid = Set[]
         @uuid_map = {}
       end
 
       def call(*hashes)
-        hashes.map(&method(:transform_hash))
+        hashes.flatten!
+        hashes.each(&method(:collect_skip_uuid))
+        hashes.map(&method(:transform))
       end
 
-      def transform_hash(h)
+      def collect_skip_uuid(hash)
+        return unless hash.key?(:id)
+        return unless hash[:id].to_s.is_uuid?
+        return unless hash.key?(:_klass)
+        return unless @skip_classes.include?(hash[:_klass])
+        @skip_classes_uuid.add(hash[:id])
+      end
+
+      def transform(hash)
         new_h = {}
-        h.each do |k, v|
-          if v.is_a?(String) && v.is_uuid?
+        hash.each do |k, v|
+          if v.is_a?(String) && v.is_uuid? && !@skip_classes_uuid.include?(v)
             unless @uuid_map[v]
               @uuid_map[v] = SecureRandom.uuid
             end

data/lib/separatum/version.rb

@@ -1,3 +1,3 @@
 module Separatum
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/separatum.rb

@@ -1,5 +1,3 @@
-require "separatum/version"
-
 Dir[File.expand_path(File.join(__FILE__, %w(.. ** *.rb)))].each(&method(:require))
 
 module Separatum
@@ -22,12 +20,11 @@ module Separatum
     end
 
     def call(*options)
-      current_options = options
       current_result = nil
       @stack.each do |el|
         klass, *params = el
         instance = klass.new(*params)
-        current_result = instance.(*(current_result || current_options))
+        current_result = instance.(current_result || options)
       end
       current_result
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: separatum
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Anton Osenenko
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-16 00:00:00.000000000 Z
+date: 2019-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -71,18 +71,21 @@ files:
 - lib/separatum.rb
 - lib/separatum/converters/hash2_object.rb
 - lib/separatum/converters/object2_hash.rb
+- lib/separatum/core_ext.rb
 - lib/separatum/exporters/active_record.rb
 - lib/separatum/exporters/active_record_code.rb
 - lib/separatum/exporters/active_record_code/attribute.rb.erb
 - lib/separatum/exporters/active_record_code/object.rb.erb
+- lib/separatum/exporters/active_record_code/program.rb.erb
 - lib/separatum/exporters/active_record_code/transaction.rb.erb
 - lib/separatum/exporters/json_file.rb
+- lib/separatum/graph_viz/drawer.rb
+- lib/separatum/graph_viz/proxy.rb
 - lib/separatum/importers/active_record.rb
 - lib/separatum/importers/json_file.rb
-- lib/separatum/object.rb
+- lib/separatum/processors/field_changer.rb
 - lib/separatum/processors/inspect.rb
 - lib/separatum/processors/uuid_changer.rb
-- lib/separatum/string.rb
 - lib/separatum/version.rb
 - separatum.gemspec
 homepage: https://github.com/a0s/separatum

data/lib/separatum/object.rb

@@ -1,5 +0,0 @@
-class Object
-  def is_one_of_a?(*types)
-    types.flatten.any? { |t| self.class.to_s == t.to_s }
-  end
-end

data/lib/separatum/string.rb

@@ -1,5 +0,0 @@
-class String
-  def is_uuid?
-    !!self.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/)
-  end
-end