usine 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 989d0ef56df43856ceb3ceee137fdaf56c5d722a
-  data.tar.gz: 79dc66c1c26e026fb6bbfa87955a394582042701
+  metadata.gz: 03d1e6d91e2856f9104d7a7c7b6907988674cdf8
+  data.tar.gz: 7573d835285b97a7243304ab437bd43ae425e150
 SHA512:
-  metadata.gz: 2b3cc1296fc2abf5c986101c85742ba18baafc109a55f0700d5d9c6c9361e312701cc2c0488935f8abafd46b1cba1f00cdc04d495e2273e704133ce4ea9dd0cd
-  data.tar.gz: c12b2dfda625558ead73b5cfc1581ae9791ca210b549e569769b4ed93e56c6b515793502f2b837b0e8f281fe7d432e0d29413f10a17d099ec88886d300a82cbb
+  metadata.gz: fcc0c03dff27f57b4a1d63eda0c11803ee7bb8fee770b8eb9fa2378fe0851b65fa6eddee7003741d89a8a15351b49585fe1ba013603e9332eb26387fc4537028
+  data.tar.gz: df77515eb45fe2bec61f553fa20c7e696beb544ca93a753895bbf28f4772bd17fec5fa7ae59219d03d30e710648017ca0480eef1343dc3288705e2a73f21436e

data/.gitignore

@@ -7,3 +7,5 @@
 /pkg/
 /spec/reports/
 /tmp/
+
+*.gem

data/README.md

@@ -1,9 +1,6 @@
 # Usine
 
-Usine (french word for factory) is a small gem aiming to bring a limited feature set of factory_girl
-when using Trailblazer’s operations. [Trailblazer](http://trailblazer.to/) advocates against using factory_girl to avoid
-differences when initializing objects. Usine follows this path but allows you to define defaults for the
-parameters passed to your operations.
+Usine (french word for factory) is a wrapper around factory_girls with two goals: simplify using [Trailblazer](http://trailblazer.to/) with factory_girl, and avoid initializing models through factory_girl instead of Trailblazer.
 
 ## Installation
 
@@ -23,72 +20,96 @@ Or install it yourself as:
 
 ## Usage
 
-### Definitions
-
-Definitions are the base of anything in Usine, they are used in factories to generate
-the hash of params sent to the operation.
+Usine let you reuse your factories and use them to define the params sent to your Operation.
 
 ```ruby
-Usine.definition(:item) do
-  title { "Some title" }
+FactoryGirl.define do
+  factory :item do
+    title { "Default title"}
+  end
+
+  factory :user do
+    email { "xx@exxample.com"}
+  end
 end
 
-Usine.definition(:user) do
-  email { "j.jaffeux@example.com" }
+# If no symbol given, Usine will try to find an existing factory with this name
+Usine.operation(Item::Create) do
+  item
+  current_user :user
 end
-```
 
-### Factories
+# Usine will transmit [call, run, present] to the operation invocation
+# so you can have the kind of operation you want in your test
+# for example `present` will not run process in your Operation
+Usine.(Item::Create, item: {title: "Another title"})
+Usine.call(Item::Create, item: {title: "Another title"})
+Usine.run(Item::Create, item: {title: "Another title"})
+Usine.present(Item::Create, item: {title: "Another title"})
+```
 
-Factories let you build a hash which will be sent to an operation when you need it.
-This is what you will call when building your objects in a test.
+### Model less factories
 
+If your params are not related to a model you can simply create a factory this way:
 ```ruby
-Usine.factory(Item::Create) do
-  item # if not block given, it will invoke use(:item), which means it will use the :item Definition
-  current_user use(:user)
+FactoryGirl.define do
+  factory :search, class:Usine::NullModel do
+    query { "*"}
+  end
 end
 ```
 
-### Invoking factories
+### Factory girl features
 
-Usine respects Trailblazer naming differences when creating an operation : call, run and present.
-Which means you have 3 different ways to invoke a factory :
+All factory_girl features should work, sequences for example are working:
 
 ```ruby
-Usine.(Item::Create, item: {title: "different title"})
-Usine.run(Item::Create, item: {title: "different title"})
-Usine.present(Item::Create, item: {title: "different title"})
+FactoryGirl.define do
+  sequence(:email) do |n|
+    "some_email_#{n}@example.com"
+  end
+
+  factory :user do
+    contact { generate(:email) }
+  end
+end
 ```
 
-`present` for example can be used to access model/contract without calling process in the operation.
+### Writing a test with Usine
 
-Let see an example in a test :
 ```
-let(:user_id) {
-  Usine.(User::Create).model.id
+# Without Usine
+let(:item) {
+  Item::Create.({
+    item: {
+      title: "DEFAULT_TITLE"
+    },
+    current_user: User::Create.(email: "some_email@example.com").model
+  }).model
 }
-```
 
-### Sequences
+# With Usine
+FactoryGirl.define do
+  factory :item do
+    title { "DEFAULT_TITLE" }
+  end
 
-Sequences are used in Definitions to help you create different occurences of the same kind of attribute.
-
-```ruby
-# global sequence
-Usine.sequence(:title) do |n|
-  "title number #{n}"
+  factory :user do
+    email { "some_email@example.com" }
+  end
 end
 
-# inline sequence in a definition
-Usine.definition(:user) do
-  sequence(:email) { |n| "joffrey_#{n}@example.com" }
-  email # if no block given, Usine will try to invoke generate(:email)
-  title # and will also search in global sequences
-  alt_email { generate(:email) }
+Usine.operation(Item::Create) do
+  item
+  current_user :user
 end
+
+let(:item) { Usine.(Item::Create).model }
 ```
 
+The second example might look more verbose, but you only have to define factories/operations one time.
+And then you can reuse it for all your tests.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/jjaffeux/usine. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

data/lib/usine.rb

@@ -1,68 +1,27 @@
+require "uber/inheritable_attr"
+require "factory_girl"
 require "usine/version"
 require "usine/utils"
-require "usine/factory"
-require "usine/factory_evaluator"
-require "usine/exceptions"
-require "usine/definition_evaluator"
-require "usine/definition"
-require "usine/sequence"
-require "uber/inheritable_attr"
+require "usine/null_model"
+require "usine/operation_factory"
+require "usine/operation_wrapper"
 
 module Usine
   extend Uber::InheritableAttr
-  inheritable_attr :definitions
-  self.definitions = []
-  inheritable_attr :factories
-  self.factories = []
-  inheritable_attr :sequences
-  self.sequences = []
+  inheritable_attr :operations
+  self.operations = []
 
   class << self
-
     [:call, :run, :present].each do |mode|
       define_method mode, ->(*args, &block) {
         operation = args.shift
-        factory = find_factory_for_operation(operation)
-        FactoryEvaluator.call(factory, mode, args.shift)
+        attributes = args.shift || {}
+        OperationWrapper.(mode, operation, attributes)
       }
     end
 
-    def factory(operation, *extensions, &block)
-      self.factories ||= []
-
-      self.factories << Factory.new(operation, *extensions, &block)
-
-      extensions.each do |extension|
-        self.factories << Factory.new(operation, *extension, &block)
-      end
-    end
-
-    def sequence(name, initial_value = 1, &block)
-      self.sequences << Sequence.new(name, initial_value, &block)
-    end
-
-    def definition(attribute, *extensions, &block)
-      self.definitions ||= []
-
-      self.definitions << Definition.new(attribute, &block)
-
-      extensions.each do |extension|
-        self.definitions << Definition.new(attribute, &block)
-      end
-    end
-
-    protected
-
-    def find_factory_for_operation(operation)
-      factory = Usine.factories.detect do |f|
-        f.operation == operation
-      end
-
-      if factory.nil?
-        raise "NOT FOUND FACTORY for #{operation}"
-      end
-
-      factory
+    def operation(operation, *args, &block)
+      self.operations << OperationFactory.new(operation, &block)
     end
   end
 end

data/lib/usine/null_model.rb

@@ -0,0 +1,3 @@
+module Usine
+  class NullModel; end
+end

data/lib/usine/operation_factory.rb

@@ -0,0 +1,31 @@
+module Usine
+  class OperationFactory
+    attr_reader :operation_class
+
+    def initialize(operation_class, &block)
+      @operation_class = operation_class
+      @block = block
+      @attributes = {}
+    end
+
+    def process
+      self.instance_eval(&@block)
+      @attributes
+    end
+
+    def method_missing(method_symbol, factory_name = nil, &block)
+      if factory_name
+        @attributes[method_symbol] = attributes_for_factory_name(factory_name)
+      else
+        @attributes[method_symbol] = attributes_for_factory_name(method_symbol)
+      end
+    end
+
+    protected
+
+    def attributes_for_factory_name(name)
+      factory = FactoryGirl.factory_by_name(name)
+      factory.run(FactoryGirl::Strategy::AttributesFor, {})
+    end
+  end
+end

data/lib/usine/operation_wrapper.rb

@@ -0,0 +1,49 @@
+module Usine
+  class OperationWrapper
+    def initialize(mode, operation, attributes = {})
+      @mode = mode
+      @operation = operation
+      @operation_factory = find_operation_factory(operation)
+      @attributes = attributes
+    end
+
+    def operations=(operations)
+      @operations = operations
+    end
+
+    def operations
+      @operations ||= Usine.operations
+    end
+
+    def self.call(mode, operation, attributes = {})
+      wrapper = new(mode, operation, attributes)
+      wrapper.process
+    end
+
+    def process
+      factory_attributes = @operation_factory.process
+      merged_attributes = Utils.merge_hashes(factory_attributes, @attributes)
+      @operation.send(@mode, merged_attributes)
+    end
+
+    protected
+
+    def find_operation_factory(operation_class)
+      operation_factory = operations.detect do |op|
+        op.operation_class == operation_class
+      end
+
+      unless operation_factory
+        message = <<-MSG
+Couldn’t find an operation factory for: #{operation_class}
+
+Please define it with:
+Usine.operation(#{operation_class}) {}
+MSG
+        raise(ArgumentError, message)
+      end
+
+      operation_factory
+    end
+  end
+end

data/lib/usine/version.rb

@@ -1,3 +1,3 @@
 module Usine
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/usine.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency             "uber"
+  spec.add_dependency             "factory_girl"
 
   spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: usine
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Joffrey JAFFEUX
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -98,12 +112,9 @@ files:
 - bin/console
 - bin/setup
 - lib/usine.rb
-- lib/usine/definition.rb
-- lib/usine/definition_evaluator.rb
-- lib/usine/exceptions.rb
-- lib/usine/factory.rb
-- lib/usine/factory_evaluator.rb
-- lib/usine/sequence.rb
+- lib/usine/null_model.rb
+- lib/usine/operation_factory.rb
+- lib/usine/operation_wrapper.rb
 - lib/usine/utils.rb
 - lib/usine/version.rb
 - usine.gemspec

data/lib/usine/definition.rb

@@ -1,11 +0,0 @@
-module Usine
-  class Definition
-    attr_reader :name
-    attr_reader :block
-
-    def initialize(name, *args, &block)
-      @name = name
-      @block = block
-    end
-  end
-end

data/lib/usine/definition_evaluator.rb

@@ -1,39 +0,0 @@
-module Usine
-  class DefinitionEvaluator
-    attr_reader :attributes
-    attr_reader :sequences
-    attr_reader :scoped_sequences
-
-    def initialize(sequences = [])
-      @sequences = sequences
-      @scoped_sequences = []
-      @attributes = {}
-    end
-
-    def method_missing(method_symbol, *args, &block)
-      if block
-        @attributes[method_symbol] = block.call
-      else
-        @attributes[method_symbol] = generate(method_symbol)
-      end
-    end
-
-    def generate(attribute)
-      if sequence = scoped_sequences.detect { |x| x.attribute == attribute }
-        sequence.next
-      elsif sequence = sequences.detect { |x| x.attribute == attribute }
-        sequence.next
-      else
-        message = <<-MSG
-Couldn’t find a sequence named: #{attribute}
-Available sequences: #{scoped_sequences.concat(sequences).map(&:attribute).join(',')}
-MSG
-        raise(UsineError::SequenceNotFound, message)
-      end
-    end
-
-    def sequence(name, initial_value = 1, &block)
-      @scoped_sequences << Sequence.new(name, initial_value, &block)
-    end
-  end
-end

data/lib/usine/exceptions.rb

@@ -1,11 +0,0 @@
-class UsineError < StandardError
-end
-
-class UsineError::DefinitionNotFound < UsineError
-end
-
-class UsineError::SequenceNotFound < UsineError
-end
-
-class UsineError::SequenceInvalidInitialValue < UsineError
-end

data/lib/usine/factory.rb

@@ -1,13 +0,0 @@
-module Usine
-  class Factory
-    attr_reader :operation
-    attr_reader :attributes
-    attr_reader :block
-
-    def initialize(operation, attributes = {}, &block)
-      @operation = operation
-      @attributes = attributes
-      @block = block
-    end
-  end
-end

data/lib/usine/factory_evaluator.rb

@@ -1,73 +0,0 @@
-module Usine
-  class FactoryEvaluator
-    attr_reader :mode
-    attr_reader :attributes
-    attr_reader :generated_attributes
-    attr_reader :factory
-
-    def self.call(factory, mode, attributes = {})
-      factory = new(factory, mode, attributes)
-      factory.process!
-    end
-
-    def definitions=(definitions)
-      @definitions = definitions
-    end
-
-    def definitions
-      @definitions ||= Usine.definitions
-    end
-
-    def sequences=(sequences)
-      @sequences = sequences
-    end
-
-    def sequences
-      @sequences ||= Usine.sequences
-    end
-
-    def initialize(factory, mode, attributes = {})
-      @mode = mode
-      @factory = factory
-      @attributes = attributes
-      @generated_attributes = {}
-    end
-
-    def use(definition_name, *args)
-      definition = definitions.detect do |definition|
-        definition.name == definition_name
-      end
-
-      if definition.nil?
-        message = <<-MSG
-Couldn’t find a definition named: #{definition_name}
-Available definitions: #{definitions.map(&:name).join(',')}
-MSG
-        raise(UsineError::DefinitionNotFound, message)
-      end
-
-      evaluated_definition = DefinitionEvaluator.new(sequences)
-      evaluated_definition.instance_eval(&definition.block)
-      evaluated_definition.attributes
-    end
-
-    def method_missing(method_symbol, *args, &block)
-      if block
-        @generated_attributes[method_symbol] = self.instance_eval(&block)
-      else
-        @generated_attributes[method_symbol] = use(method_symbol, *args)
-      end
-    end
-
-    def process!
-      self.instance_eval(&factory.block)
-      @factory.operation.send(@mode, merged_attributes)
-    end
-
-    protected
-
-    def merged_attributes
-      Utils.merge_hashes(@generated_attributes, @attributes)
-    end
-  end
-end

data/lib/usine/sequence.rb

@@ -1,21 +0,0 @@
-module Usine
-  class Sequence
-    attr_reader :attribute
-
-    def initialize(attribute, *args, &block)
-      @attribute = attribute
-      @block = block
-      @value = args.first || 1
-
-      unless @value.respond_to?(:next)
-        raise(UsineError::SequenceInvalidInitialValue, "Invalid initial value, it must respond to #next")
-      end
-    end
-
-    def next
-      @block.call(@value)
-    ensure
-      @value = @value.next
-    end
-  end
-end