massager 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d2d0b338f8b5b13f2f4e6eb7a3e2f918e17f6804
-  data.tar.gz: 4c593d00ad891621d637a9f3d61bd1ec9e01fa41
+  metadata.gz: c76b7d2aefdb4e9d17182759b7c7abcf25793f8b
+  data.tar.gz: eb96295d2ede881cf36fd89540fc16f805269c4b
 SHA512:
-  metadata.gz: a8d823265174713d074e43f90620bc97aab685d28869fe7961ae434b60bb1707910bb6b09df9d91bf9c7c016e9b9378959a74d9971233a0cc4ba840985f2e4d1
-  data.tar.gz: c2da37ebbe135a94e7994eda38073f8763c2a5b030a8bcbe4e4943611e63f7ebaffc60ab89cf7d6fdae4589c755c09324b306e52cbe86faf571d5e1c0124e8aa
+  metadata.gz: aafea83a72a4438db9be150cb8c4c230d1c12b33901214a2cec88f864afaa6c5b77adcd3fde16d75e78303042ca1663eb3ac8d08ace0f84d3775a435841ba3ac
+  data.tar.gz: 9fb64863a5619f31690f6d440e7602f4e1049254b95a2fcbeffb787c7d1fb42d780a8dc50e2f81be3865569481fd8f38348754195788cf86e85abbc78416a47b

data/README.md

@@ -28,7 +28,7 @@ end
 ```
 In this scenario, the "bar" key's value will become the result `foo` method
 ```ruby
-testable = ExampleClass.build({"bar" => "value"})
+testable = ExampleClass.call({"bar" => "value"})
 testable.foo #=> "value"
 ```
 ## Strict schema
@@ -41,9 +41,9 @@ end
 ```
 It will raise an error if "bar" is not passed:
 ```ruby
-testable = ExampleClass.build({"bar" => "value"})
+testable = ExampleClass.call({"bar" => "value"})
 testable.foo #=> "value"
-testable = ExampleClass.build({"baz" => "value"}) #=> raises ArgumentError
+testable = ExampleClass.call({"baz" => "value"}) #=> raises ArgumentError
 ```
 
 ## Type checking
@@ -56,9 +56,9 @@ end
 ```
 It will raise an error if the type is not correct:
 ```ruby
-testable = ExampleClass.build({"bar" => "value"})
+testable = ExampleClass.call({"bar" => "value"})
 testable.foo #=> "value"
-testable = ExampleClass.build({"bar" => 123})
+testable = ExampleClass.call({"bar" => 123})
 testable.foo #=> raises Dry::Types::ConstraintError
 ```
 If you want to define your own types, check the Dry Types library. Type needs to respond to `call` method, so 
@@ -77,7 +77,7 @@ end
 ```
 And it will have following result
 ```ruby
-testable = ExampleClass.build({"bar" => "value"})
+testable = ExampleClass.call({"bar" => "value"})
 testable.foo #=> "VALUE"
 ```
 
@@ -94,53 +94,10 @@ end
 Note that if you pass multiple keys, the modifier block is mandatory
 
 ```ruby
-testable = ExampleClass.build({"bar" => "bar", "baz" => "baz"})
+testable = ExampleClass.call({"bar" => "bar", "baz" => "baz"})
 testable.foo #=> "bar baz"
 ```
 
-## Enum attributes
-If you want to have enum as a result, you will need to use `enum_attribute`
-```ruby
-class ExampleClass
-  include Massager
-  enum_attribute :foo, "bar", "baz"
-end
-```
-```ruby
-testable = ExampleClass.build({"bar" => "bar", "baz" => "baz"})
-testable.foo #=> ["bar", "baz"]
-```
-
-## Enum attribute with modifier
-You can apply modifications to the collection
-```ruby
-class ExampleClass
-  include Massager
-  enum_attribute :foo, "bar", "baz" do |values| 
-    values.reverse
-  end
-end
-```
-```ruby
-testable = ExampleClass.build({"bar" => "bar", "baz" => "baz"})
-testable.foo #=> ["baz", "bar"]
-```
-
-## Enum attribute with type check
-You can provide type checks as well
-```ruby
-class ExampleClass
-  include Massager
-  enum_attribute :foo, "bar", "baz", type: Types::Strict::Array.member(Types::Strict::String)
-end
-```
-```ruby
-testable = ExampleClass.build({"bar" => "bar", "baz" => "baz"})
-testable.foo #=> ["bar", "baz"]
-
-testable = ExampleClass.build({"bar" => 123, "baz" => "baz"}) # Will raise Dry::Types::ConstraintError
-```
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/massager/attributes/attribute_with_multiple_keys.rb

@@ -0,0 +1,25 @@
+module Massager
+  class AttributeWithMultipleKeys
+    def initialize(name:, keys:, opts: {}, block: nil)
+      raise ArgumentError, "If you pass multiple keys, you have to use modifier block" if block.nil?
+      @name, @keys, @opts, @block = name, keys, opts, block
+    end
+
+    def call(values)
+      values = values.values_at(*keys)
+      values = block.call(*values)
+      Dry::Monads::Maybe(opts[:type]).fmap {|type| values = type.call(*values)}
+      values
+    end
+
+    def return_result(values)
+      values
+    end
+
+    def match_schema?(attrs)
+      (attrs.keys & keys).any?
+    end
+
+    attr_reader :keys, :block, :opts, :name
+  end
+end

data/lib/massager/attributes/attribute_with_single_key.rb

@@ -0,0 +1,20 @@
+module Massager
+  class AttributeWithSingleKey
+    def initialize(name:, key:, opts: {}, block: nil)
+      @name, @key, @opts, @block = name, key, opts, block
+    end
+
+    def call(values)
+      value = values.fetch(key)
+      Dry::Monads::Maybe(block).fmap {|block| value = block.call(value)}
+      Dry::Monads::Maybe(opts[:type]).fmap {|type| value = type.call(value)}
+      value
+    end
+
+    def match_schema?(attrs)
+      attrs.keys.include?(key)
+    end
+
+    attr_reader :key, :block, :opts, :name
+  end
+end

data/lib/massager/version.rb

@@ -1,3 +1,3 @@
 module Massager
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/lib/massager.rb

@@ -4,33 +4,31 @@ require "dry-monads"
 require "dry-container"
 require "set"
 
-require "massager/attributes/attribute"
-require "massager/attributes/enum_attribute"
+require "massager/attributes/attribute_with_single_key"
+require "massager/attributes/attribute_with_multiple_keys"
 
 module Massager
   module ClassMethods
     def attribute(name, *target_keys, **opts, &block)
-      register_attribute(
-        Attribute.new(name: name, target_keys: target_keys, opts: opts, block: block)
-      )
-      add_keys_to_schema(opts, target_keys)
-      define_setter(name)
-      define_getter(name)
-    end
-
-    def enum_attribute(name, *target_keys, **opts, &block)
-      register_attribute(
-        EnumAttribute.new(name: name, target_keys: target_keys, opts: opts, block: block)
-      )
+      case
+      when target_keys.count > 1
+        register_attribute(
+          AttributeWithMultipleKeys.new(name: name, keys: target_keys, opts: opts, block: block)
+        )
+      when target_keys.count == 1
+        register_attribute(
+          AttributeWithSingleKey.new(name: name, key: target_keys.first, opts: opts, block: block)
+        )
+      end
       add_keys_to_schema(opts, target_keys)
       define_setter(name)
       define_getter(name)
     end
 
-    def build(attrs)
+    def call(attrs)
       check_schema(attrs)
       instance = new
-      each_key do |k|
+      _container.each_key.select {|a| a.include?("attributes.")}.each do |k|
         attribute = resolve(k)
         instance.public_send("#{attribute.name}=", attrs) if attribute.match_schema?(attrs)
       end
@@ -41,9 +39,10 @@ module Massager
 
     def check_schema(attrs)
       attr_keys = attrs.keys.to_set
-      if key?(:schema)
-        schema = resolve(:schema)
-        raise ArgumentError, "Missing keys: #{(schema - attr_keys).to_a}" unless schema.superset?(attr_keys) 
+      if _container.key?("schema")
+        schema = resolve("schema")
+        attr_keys = attr_keys.find_all {|a| schema.include?(a)}
+        raise ArgumentError, "Missing keys: #{(schema - attr_keys).to_a}" unless schema.subset?(attr_keys.to_set)
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: massager
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Janis Miezitis
@@ -99,8 +99,8 @@ files:
 - bin/console
 - bin/setup
 - lib/massager.rb
-- lib/massager/attributes/attribute.rb
-- lib/massager/attributes/enum_attribute.rb
+- lib/massager/attributes/attribute_with_multiple_keys.rb
+- lib/massager/attributes/attribute_with_single_key.rb
 - lib/massager/version.rb
 - massager.gemspec
 homepage: http://github.com/janjiss/massager

data/lib/massager/attributes/attribute.rb

@@ -1,29 +0,0 @@
-module Massager
-  class Attribute
-    def initialize(name:, target_keys:, opts: {}, block: nil)
-      raise ArgumentError, "If you pass multiple keys, you have to use modifier block" if block.nil? && target_keys.count > 1
-      @name, @target_keys, @opts, @block = name, target_keys, opts, block
-    end
-
-    def call(values)
-      begin
-        values = values.values_at(*target_keys)
-        Dry::Monads::Maybe(block).fmap {|block| values = block.call(*values)}
-        Dry::Monads::Maybe(opts[:type]).fmap {|type| values = type.call(*values)}
-        return_result(*values)
-      rescue ArgumentError
-        raise ArgumentError, "The result of modifier block should return single element"
-      end
-    end
-
-    def return_result(values)
-      values
-    end
-
-    def match_schema?(attrs)
-      (attrs.keys & target_keys).any?
-    end
-
-    attr_reader :target_keys, :block, :opts, :name
-  end
-end

data/lib/massager/attributes/enum_attribute.rb

@@ -1,21 +0,0 @@
-module Massager
-  class EnumAttribute
-    def initialize(name:, target_keys:, opts: {}, block:)
-      @name, @target_keys, @opts, @block = name, target_keys, opts, block
-    end
-
-    def call(values)
-      values = values.values_at(*target_keys)
-      Dry::Monads::Maybe(block).fmap {|block| values = block.call(values)}
-      Dry::Monads::Maybe(opts[:type]).fmap {|type| values = type.call(values)}
-      raise ArgumentError, "The result of modifier block is not an enum" unless values.respond_to? :each
-      values
-    end
-
-    def match_schema?(attrs)
-      (attrs.keys & target_keys).any?
-    end
-
-    attr_reader :target_keys, :block, :opts, :name
-  end
-end