usable 3.3.0 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 37d7979f36f818a019b5e938f9271a09021d8740
-  data.tar.gz: 52f7607ba637d7e1e50c2423797c0680c390af47
+  metadata.gz: eb11e2617182a394ba2fcf207926152e7cb93606
+  data.tar.gz: 2d7c5698ddd7a8984a791c29cad205f65a0ab6ab
 SHA512:
-  metadata.gz: be661c7880726a1fd3235c88c6ac27218f5ed88dad72088ee72da40493ba54208e71743c8951c424095936249a09c2c8db329f262e781be683088d6a4fa0d7bf
-  data.tar.gz: d074eea1d75951eaf494de6680a94d2cea4f721324570ef50a39c147276fedf85adac77ca5c464cc9d46a1e99a6a6a4d6281e992573196b8f2536affcdde4f6d
+  metadata.gz: 7d0835d8eff617914a7968af009e307804f638191f7025dc06a54bd8b89cdf205ea2c13a14ac92de4471f96e91ebfc1d8990d08df5ea78f5d33a42d1c7f05546
+  data.tar.gz: 485649445fcbc569624de03000756b61fe972686432d14c6b67db88b3f8988afc1db0109f1e6750f56b7f6c5f68b4aafeb23873b45218dc78cbf181f4aaa905b

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+3.4.0 (12/22/2016)
+==================
+
+* FIX - Copying usable attributes from a module to class/module works as expected
+* NEW - Pass `only: :constants` when mounting a module to import just the constants from a module
+
 3.3.0 (12/4/2016)
 =================
 

data/README.md

@@ -3,7 +3,17 @@
 Usable provides an elegant way to mount and configure your modules. Class level settings can be configured on a per module basis,
 available to both the module and including class. Allows you to include only the methods you want. 
 
-Configure a module to be usable
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'usable'
+```
+
+## Usage
+
+Configure a module to have "usable" defaults:
 ```ruby
 module VersionMixin
   extend Usable
@@ -24,7 +34,7 @@ module VersionMixin
 end
 ```
 
-Include the module into a class using `usable`, which will copy over any configuration options
+Include the module into a class using `usable`, which will copy over the configs:
 ```ruby
 class Model
   extend Usable
@@ -118,15 +128,32 @@ So Usable gives the modified module a name, which is the same name as the origin
 Mixin => MixinUsed
 ```
 
-## Installation
+## Tips and Tricks
 
-Add this line to your application's Gemfile:
+#### __3.4__ _-(unreleased)_
+
+Import just a module's constants:
 
 ```ruby
-gem 'usable'
+usable ExampleMod, only: :constants
 ```
 
-## Tips and Tricks
+Currently works with `usable ExampleMod, only: []` since version 2.0
+
+#### __since version 3.3__ _- (not required)_
+The `Usable::Struct` function is available for creating value objects with defaults. If you `require "usable/struct"` the
+class function is available to create classes:
+
+```ruby
+class Route < Usable::Struct(paths: %w[api v2 v3])
+end
+
+Route.usables.to_h          # => {:paths=>["api", "v2", "v3"]}
+Route.new.paths             # => ["api", "v2", "v3"] 
+Route.new(paths: nil).paths # => nil
+```
+
+#### __since version 2.0__
 
 When usable modules define the same config setting, the last one mounted takes precedence. Fortunately,
 Usable also "stacks" config settings by namespacing them:
@@ -156,12 +183,6 @@ User.usables.human.speak # => "Hello"
 User.usables.robot.speak # => "beep bop"
 ```
 
-Import just a module's constants with this little trick:
-
-```ruby
-usable ExampleMod, only: []
-```
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/bin/console

@@ -3,6 +3,7 @@
 require "bundler/setup"
 require "usable"
 require "usable/struct"
+require "byebug"
 require "irb"
 
 # You can add fixtures and/or initialization code here to make experimenting
@@ -78,4 +79,21 @@ end
 
 Model.usable PersistenceOverride, method: 'prepend'
 
+def run_tests(subject)
+  if subject.usables.instance_variable_get(:@lazy_loads).to_a != [:model]
+    puts "Test @lazy_loads FAILED! Expected: #{[:model]}, Actual: #{subject.usables.instance_variable_get(:@lazy_loads)}"
+  end
+  if subject.usables.model != Model
+    puts "Test #model FAILED! Expected: #{Model}, Actual: #{subject.usables.model}"
+  end
+  if subject.usables.max_versions != 10
+    puts "Test #max_version FAILED! Expected: #{10}, Actual: #{subject.usables.max_versions}"
+  end
+  if subject.usables.model.new.save != 'nope'
+    puts "Test #save FAILED! Expected: 'nope', Actual: #{subject.usables.model.new.save}"
+  end
+end
+
+run_tests Example
+
 IRB.start

data/lib/usable/config.rb

@@ -8,6 +8,7 @@ module Usable
     include ConfigRegister
     include ConfigMulti
 
+    # @todo Maybe keep a list of all attributes (lazy and regular)?
     def initialize(attributes = {})
       @spec = OpenStruct.new(attributes)
       @lazy_loads = Set.new
@@ -42,17 +43,23 @@ module Usable
     end
 
     def method_missing(key, *args, &block)
+      # @attributes << key.to_s
       if block
         @lazy_loads << key
-        # @attributes << key.to_s
         @spec.define_singleton_method(key) { yield }
       else
-        key = key.to_s.tr('=', '')
-        # @attributes << key
+        # Needs to be a symbol so we can consistently access @lazy_loads
+        key = key.to_s.tr('=', '').to_sym
         if args.empty?
-          value = @spec[key] ||= call_spec_method(key)
+          if @spec[key]
+            # Cleanup, just in case we loaded it another way (e.g. combining with another usable config)
+            @lazy_loads.delete key
+          else
+            @spec[key] = call_spec_method(key)
+          end
+          # Define method so we don't hit method missing again
           define_singleton_method(key) { @spec[key] }
-          value
+          @spec[key]
         else
           @spec[key] = args.first
         end

data/lib/usable/config_multi.rb

@@ -1,17 +1,19 @@
 module Usable
   module ConfigMulti
     # It's important to define all block specs we need to lazy load
-    # Set block specs to nil values so it will fallback to calling the underlying singleton method defined by Config#method_missing
     def +(other)
       config = clone
       specs = other.spec.to_h
       specs.each { |key, val| config[key] = val }
-      methods = other.spec.singleton_methods - specs.keys
+      methods = other.spec.singleton_methods
+      methods.map! { |name| name.to_s.tr('=', '').to_sym }
+      methods.uniq!
+      methods -= specs.keys
       methods.each do |name|
-        config.spec[name] = nil
         config.spec.define_singleton_method(name) do
           other.spec.public_method(name).call
         end
+        config.instance_variable_get(:@lazy_loads) << name
       end
       config
     end

data/lib/usable/mod_extender.rb

@@ -9,7 +9,7 @@ module Usable
       @options[:method] ||= :include
       @copy = mod
       @name = mod.name
-      @unwanted = options[:only] ? @copy.instance_methods - Array(options[:only]) : []
+      @unwanted = find_unwanted_methods(options[:only])
       if @unwanted.any?
         @copy = @copy.dup
       end
@@ -37,5 +37,14 @@ module Usable
         "UsableMod#{Time.now.strftime('%s')}"
       end
     end
+
+    def find_unwanted_methods(only)
+      return [] unless only
+      if :constants == only
+        @copy.instance_methods
+      else
+        @copy.instance_methods - Array(only)
+      end
+    end
   end
 end

data/lib/usable/version.rb

@@ -1,3 +1,3 @@
 module Usable
-  VERSION = "3.3.0".freeze
+  VERSION = "3.4.0".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: usable
 version: !ruby/object:Gem::Version
-  version: 3.3.0
+  version: 3.4.0
 platform: ruby
 authors:
 - Ryan Buckley
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-05 00:00:00.000000000 Z
+date: 2016-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler