usine 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fbc2a69385641d964ee71c8d4aec4dca3237fbea
-  data.tar.gz: 50b1d8c0d0eb7d9f122bc3abf59dbb35da29b7cc
+  metadata.gz: 989d0ef56df43856ceb3ceee137fdaf56c5d722a
+  data.tar.gz: 79dc66c1c26e026fb6bbfa87955a394582042701
 SHA512:
-  metadata.gz: 898bc72b754b1eca6709814eef4424e5d199273d8ba4a88fd38a7f16a59faf11dc04a9a02949c7fa336d0ac46277290f6bb4e5009ba2f90babaa200081a253f9
-  data.tar.gz: 211d45fe40c5457f3313e9802413e2d478c69541c423b16b4a0bc09528b25e0f0fd292602f21091f2dd9db22a2ec2b558aca11e0a9d6afa9b3b8bae2e76f0c37
+  metadata.gz: 2b3cc1296fc2abf5c986101c85742ba18baafc109a55f0700d5d9c6c9361e312701cc2c0488935f8abafd46b1cba1f00cdc04d495e2273e704133ce4ea9dd0cd
+  data.tar.gz: c12b2dfda625558ead73b5cfc1581ae9791ca210b549e569769b4ed93e56c6b515793502f2b837b0e8f281fe7d432e0d29413f10a17d099ec88886d300a82cbb

data/README.md

@@ -23,63 +23,69 @@ Or install it yourself as:
 
 ## Usage
 
-### Create definitions to be used by factories
+### Definitions
+
+Definitions are the base of anything in Usine, they are used in factories to generate
+the hash of params sent to the operation.
 
 ```ruby
-Usine.definition(Item::Create) do
+Usine.definition(:item) do
   title { "Some title" }
 end
+
+Usine.definition(:user) do
+  email { "j.jaffeux@example.com" }
+end
 ```
 
-Definition accept unlimited args after the operation class, to allow you to share
-definitions.
+### Factories
 
-```ruby
-SendableDefinition = proc {
-  sendable { false }
-}
+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.
 
-Usine.definition(Item::Create, SendableDefinition) do
-  title { "Some title" }
-end
-
-Usine.definition(Item::Update, SendableDefinition) do
-  title { "Some title" }
+```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)
 end
 ```
 
-### Using factories
+### Invoking factories
 
 Usine respects Trailblazer naming differences when creating an operation : call, run and present.
+Which means you have 3 different ways to invoke a factory :
 
 ```ruby
-Usine.(Item::Create, title: "different title")
-Usine.call(Item::Create, title: "different title")
-Usine.run(Item::Create, title: "different title")
-Usine.present(Item::Create, title: "different title")
+Usine.(Item::Create, item: {title: "different title"})
+Usine.run(Item::Create, item: {title: "different title"})
+Usine.present(Item::Create, item: {title: "different title"})
 ```
 
 `present` for example can be used to access model/contract without calling process in the operation.
 
+Let see an example in a test :
+```
+let(:user_id) {
+  Usine.(User::Create).model.id
+}
+```
+
 ### Sequences
 
+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}"
 end
 
-# if no block is passed to the attribute, it will call generate(:attribute_name)
-Usine.definition(Item::Create) do
-  title #title number 1
-  subtitle { generate(:title) } #title number 2
-end
-
-# inline sequence with different initial value
-Usine.definition(Item::Create) do
-  sequence(:title, 'a')
-  title #title number a
-  subtitle { generate(:title) } #title number b
+# 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) }
 end
 ```
 

data/lib/usine/{evaluator.rb → definition_evaluator.rb}

@@ -1,10 +1,10 @@
 module Usine
-  class Evaluator
+  class DefinitionEvaluator
     attr_reader :attributes
     attr_reader :sequences
     attr_reader :scoped_sequences
 
-    def initialize(sequences = {})
+    def initialize(sequences = [])
       @sequences = sequences
       @scoped_sequences = []
       @attributes = {}
@@ -24,7 +24,11 @@ module Usine
       elsif sequence = sequences.detect { |x| x.attribute == attribute }
         sequence.next
       else
-        raise(UsineError::SequenceNotFound, "Couldn’t find a sequence named : `#{attribute}`")
+        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
 

data/lib/usine/factory.rb

@@ -1,55 +1,13 @@
 module Usine
   class Factory
-    attr_reader :mode
     attr_reader :operation
     attr_reader :attributes
-    attr_accessor :definition
+    attr_reader :block
 
-    def self.call(mode, operation, attributes = {})
-      factory = new(mode, operation, attributes, definitions)
-      factory.process!
-    end
-
-    def initialize(mode, operation, attributes = {})
-      @mode = mode
+    def initialize(operation, attributes = {}, &block)
       @operation = operation
-      @definitions = attributes.delete(:definitions) || Usine.definitions.fetch(operation, [])
-      @sequences = attributes.delete(:sequences) || Usine.sequences
-      @attributes = attributes || {}
-    end
-
-    def process!
-      @operation.send(@mode, merged_attributes)
-    end
-
-    def merged_attributes
-      evaluated_factory.attributes.merge(@attributes)
-    end
-
-    def evaluated_factory
-      @evaluated_factory ||= evaluate_with_definitions(@sequences)
-    end
-
-    protected
-
-    def filtered_definitions
-      filtered = @definitions.select do |definition|
-        definition.name == @operation
-      end
-
-      if filtered.empty?
-        raise UsineError::DefinitionNotFound, "No definition found for `#{@operation}`"
-      end
-
-      filtered
-    end
-
-    def evaluate_with_definitions(sequences)
-      evaluator = Evaluator.new(sequences)
-      filtered_definitions.each do |definition|
-        evaluator.instance_eval(&definition.block)
-      end
-      evaluator
+      @attributes = attributes
+      @block = block
     end
   end
 end

data/lib/usine/factory_evaluator.rb

@@ -0,0 +1,73 @@
+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/utils.rb

@@ -0,0 +1,17 @@
+module Usine
+  class Utils
+    def self.merge_hashes(a, b)
+      b.each_pair do |current_key, other_value|
+        this_value = a[current_key]
+
+        a[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
+          Usine::Utils.merge_hashes(this_value, other_value)
+        else
+          other_value
+        end
+      end
+
+      a
+    end
+  end
+end

data/lib/usine/version.rb

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

data/lib/usine.rb

@@ -1,7 +1,9 @@
 require "usine/version"
+require "usine/utils"
 require "usine/factory"
+require "usine/factory_evaluator"
 require "usine/exceptions"
-require "usine/evaluator"
+require "usine/definition_evaluator"
 require "usine/definition"
 require "usine/sequence"
 require "uber/inheritable_attr"
@@ -9,35 +11,58 @@ require "uber/inheritable_attr"
 module Usine
   extend Uber::InheritableAttr
   inheritable_attr :definitions
-  self.definitions = {}
+  self.definitions = []
+  inheritable_attr :factories
+  self.factories = []
   inheritable_attr :sequences
   self.sequences = []
 
   class << self
-    def call(*args)
-      Factory.(:call, args.shift, args.shift)
-    end
 
-    def run(*args)
-      Factory.(:run, args.shift, args.shift)
+    [: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)
+      }
     end
 
-    def present(*args)
-      Factory.(:present, args.shift, args.shift)
+    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(operation, *extensions, &block)
-      self.definitions[operation] ||= []
+    def definition(attribute, *extensions, &block)
+      self.definitions ||= []
 
-      self.definitions[operation] << Definition.new(operation, &block)
+      self.definitions << Definition.new(attribute, &block)
 
       extensions.each do |extension|
-        self.definitions[operation] << Definition.new(operation, &block)
+        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
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: usine
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Joffrey JAFFEUX
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-07-22 00:00:00.000000000 Z
+date: 2016-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uber
@@ -99,10 +99,12 @@ files:
 - bin/setup
 - lib/usine.rb
 - lib/usine/definition.rb
-- lib/usine/evaluator.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/utils.rb
 - lib/usine/version.rb
 - usine.gemspec
 homepage: https://github.com/jjaffeux/usine