contextuable 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8bd1b22c48cd964a9e88d7c24042a3a5237cf412
-  data.tar.gz: 29c4996901db2aaa4a4ca98618ddb2a912b11281
+  metadata.gz: f078d3e26b5f6a206f595db13edf2eeed2149f00
+  data.tar.gz: 2bffb3821243b8b7617d4b782a8cb6dadfc3f519
 SHA512:
-  metadata.gz: 7c766b2fb0e126589259d917cead49aaffbc31f97df7edb4ce649215ad50dc0b55ab9c2736b004a9096d8e1765c763ba0941298a1a07c79ff238da02b48a9999
-  data.tar.gz: 71dabd1609822f5401b0a23f98bedeba540f737c834fb96d1779611609c575a0d69780c626c01d006611891ac2df5beb112a212d126bd378ac991d853d862bb9
+  metadata.gz: 95857c57a2be144c38be622a911b71f5e22e3d92c643a2d37961fbc9fe3e2640457ae602441d4c1790942139739a5902b1ca9f7e4a484115aa15a7ba607959fb
+  data.tar.gz: 1f4a390b7c957a89044b03ecb5509060c863111f774dd86c5ce63c7e6bae6ee2efe9b92d8c9f4146c31efd7db1a1b44e1a470c73a4dbf8de8d78e6dd92e0bc96

data/README.md

@@ -71,6 +71,15 @@ i.not_permitted
 
 ### Building better Structs
 
+**no_method_error**
+```ruby
+class Example < Contextuable
+  no_method_error
+end
+
+Example.new(foo: :bar).hello # => Error: NoMethodError
+```
+
 **required**
 ```ruby
 class Example < Contextuable

data/lib/contextuable/class_methods.rb

@@ -0,0 +1,37 @@
+class Contextuable
+  module ClassMethods
+
+    def settings
+      @settings ||= {}
+    end
+
+    def required(*names)
+      settings[:required] = names.map(&:to_sym)
+    end
+
+    def no_method_error(input = true)
+      settings[:no_method_error] = input
+    end
+
+    def open_struct_behavior(input = true)
+      settings[:no_method_error] = !input
+    end
+
+    def ensure_presence(*names)
+      settings[:presence_required] = names.map(&:to_sym)
+    end
+
+    def aliases(*names)
+      settings[:equivalents] ||= []
+      settings[:equivalents] << names.map(&:to_sym)
+    end
+
+    def defaults(hash)
+      settings[:defaults] = hash
+    end
+
+    def permit(*names)
+      settings[:permitted] = names.map(&:to_sym)
+    end
+  end
+end

data/lib/contextuable/instance_methods.rb

@@ -0,0 +1,92 @@
+class Contextuable
+  module InstanceMethods
+    def initialize(hash = {})
+      check_input_errors(hash)
+      hash = hash.select{|k, v| _permitted.include?(k.to_sym) } if _only_permitted?
+      @attrs = _defaults.merge(hash)
+      attrs.each do |k, v|
+        define_contextuable_method(k, v)
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      if ary = find_in_equivalents(name)
+        _from_equivalents(ary)
+      elsif name =~ /\A\w+=\z/
+        set_attribute_macro(name, *args, &block)
+      else
+        out = provided_macro(name)
+        return out[:out] if out
+        raise NoMethodError if _no_method_error
+      end
+    end
+
+    def find_in_equivalents(name)
+      found = nil
+      _equivalents.each do |ary|
+        found = ary if ary.include?(name.to_sym)
+        break if found
+      end
+      found
+    end
+
+    def _from_equivalents(ary)
+      out = nil
+      ary.each do |method|
+        out = attrs[method.to_sym]
+        break if out
+      end
+      out
+    end
+
+    def _only_permitted?
+      _permitted.any?
+    end
+
+    def _permitted
+      _get_config[:permitted] || []
+    end
+
+    def _equivalents
+      _get_config[:equivalents] || []
+    end
+
+    def _presence_required
+      _get_config[:presence_required] || []
+    end
+
+    def _no_method_error
+      !_get_config[:no_method_error] == false
+    end
+
+    def _defaults
+      _get_config[:defaults] || {}
+    end
+
+    def _required_args
+      _get_config[:required] || []
+    end
+
+    def _get_config
+      self.class.settings
+    end
+
+    def check_input_errors(hash)
+      unless hash.class <= Hash
+        fail WrongArgument, "[Contextuable ERROR]: `#{self.class}` expects to receive a `Hash` or and object having `Hash` as ancestor."
+      end
+
+      _required_args.map(&:to_sym).each do |r|
+        unless hash.keys.map(&:to_sym).include?(r)
+          fail RequiredFieldNotPresent, "[Contextuable ERROR]: `#{self.class}` expect to be initialized with `#{r}` as an attribute."
+        end
+      end
+
+      _presence_required.map(&:to_sym).each do |r|
+        if hash[r].nil?
+          fail PresenceRequired, "[Contextuable ERROR]: `#{self.class}` expects to receive an attribute named `#{r}` not beeing `nil`"
+        end
+      end
+    end
+  end
+end

data/lib/contextuable.rb

@@ -1,48 +1,33 @@
 class Contextuable
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
+  autoload :ClassMethods, 'contextuable/class_methods'
+  autoload :InstanceMethods, 'contextuable/instance_methods'
 
   class RequiredFieldNotPresent < ArgumentError; end
   class PresenceRequired < ArgumentError; end
   class WrongArgument < ArgumentError; end
 
-  class << self
-    def required(*names)
-      @_required = names.map(&:to_sym)
-    end
-
-    def ensure_presence(*names)
-      @_presence_required = names.map(&:to_sym)
-    end
-
-    def aliases(*names)
-      @_equivalents ||= []
-      @_equivalents << names.map(&:to_sym)
-    end
-
-    def defaults(hash)
-      @_defaults = hash
-    end
-
-    def permit(*names)
-      @_permitted = names.map(&:to_sym)
-    end
+  def self.inherited(subclass)
+    subclass.extend ClassMethods
+    subclass.include InstanceMethods
   end
 
-  attr_reader :args
-  alias_method :to_h, :args
-  alias_method :to_hash, :args
+  attr_reader :attrs
+  alias_method :to_h, :attrs
+  alias_method :to_hash, :attrs
 
   def initialize(hash = {})
-    check_input_errors(hash)
-    hash = hash.select{|k, v| _permitted.include?(k.to_sym) } if _only_permitted?
-    @args = _defaults.merge(hash)
-    args.each do |k, v|
+    unless hash.class <= Hash
+      fail WrongArgument, "[Contextuable ERROR]: `#{self.class}` expects to receive a `Hash` or and object having `Hash` as ancestor."
+    end
+    @attrs = hash
+    @attrs.each do |k, v|
       define_contextuable_method(k, v)
     end
   end
 
   def [](key)
-    args[key]
+    attrs[key]
   end
 
   def []=(key, value)
@@ -50,90 +35,37 @@ class Contextuable
   end
 
   def method_missing(name, *args, &block)
-    if ary = find_in_equivalents(name)
-      _from_equivalents(ary)
-    elsif name =~ /\A\w+=\z/
-      value = args.first || block
-      key = name.to_s.gsub('=', '').to_sym
-      set_attribute(key, value)
+    if name =~ /\A\w+=\z/
+      set_attribute_macro(name, *args, &block)
     else
-      case name.to_s
-      when /\A\w+_not_provided\?\z/ then true
-      when /\A\w+_provided\?\z/ then false
-      end
+      out = provided_macro(name)
+      out ? out[:out] : nil
     end
   end
 
   private
 
-  def set_attribute(key, value)
-    args[key] = value
-    define_contextuable_method(key, value)
-  end
-
-  def define_contextuable_method(key, value)
-    define_singleton_method(key) { args.fetch(key) }
-    define_singleton_method("#{key}_provided?") { true }
-    define_singleton_method("#{key}_not_provided?") { false }
-  end
-
-  def find_in_equivalents(name)
-    found = nil
-    _equivalents.each do |ary|
-      found = ary if ary.include?(name.to_sym)
-      break if found
-    end
-    found
+  def set_attribute_macro(name, *args, &block)
+    value = args.first || block
+    key = name.to_s.gsub('=', '').to_sym
+    set_attribute(key, value)
   end
 
-  def _from_equivalents(ary)
-    out = nil
-    ary.each do |method|
-      out = args[method.to_sym]
-      break if out
+  def provided_macro(name)
+    case name.to_s
+    when /\A\w+_not_provided\?\z/ then { out: true }
+    when /\A\w+_provided\?\z/ then { out: false }
     end
-    out
   end
 
-  def _only_permitted?
-    _permitted.any?
-  end
-
-  def _permitted
-    self.class.instance_variable_get(:@_permitted) || []
-  end
-
-  def _equivalents
-    self.class.instance_variable_get(:@_equivalents) || []
-  end
-
-  def _presence_required
-    self.class.instance_variable_get(:@_presence_required) || []
-  end
-
-  def _defaults
-    self.class.instance_variable_get(:@_defaults) || {}
-  end
-
-  def _required_args
-    self.class.instance_variable_get(:@_required) || []
+  def set_attribute(key, value)
+    attrs[key] = value
+    define_contextuable_method(key, value)
   end
 
-  def check_input_errors(hash)
-    unless hash.class <= Hash
-      fail WrongArgument, "[Contextuable ERROR]: `#{self.class}` expects to receive an `Hash` or and object having `Hash` as ancestor."
-    end
-
-    _required_args.map(&:to_sym).each do |r|
-      unless hash.keys.map(&:to_sym).include?(r)
-        fail RequiredFieldNotPresent, "[Contextuable ERROR]: `#{self.class}` expect to be initialized with `#{r}` as an attribute."
-      end
-    end
-
-    _presence_required.map(&:to_sym).each do |r|
-      if hash[r].nil?
-        fail PresenceRequired, "[Contextuable ERROR]: `#{self.class}` expects to receive an attribute named `#{r}` not beeing `nil`"
-      end
-    end
+  def define_contextuable_method(key, value)
+    define_singleton_method(key) { attrs.fetch(key) }
+    define_singleton_method("#{key}_provided?") { true }
+    define_singleton_method("#{key}_not_provided?") { false }
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contextuable
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Artur Pañach
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-20 00:00:00.000000000 Z
+date: 2016-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -71,6 +71,8 @@ files:
 - bin/setup
 - contextuable.gemspec
 - lib/contextuable.rb
+- lib/contextuable/class_methods.rb
+- lib/contextuable/instance_methods.rb
 homepage: https://www.github.com/arturictus/contextuable
 licenses:
 - MIT
@@ -91,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.3
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Structs with steroids.