uber 0.0.15 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d35993c8fa8e0378bda6e3207c7a34c79fcaf901
-  data.tar.gz: 57e3c7e6251134b7c38f4e946768f795d842da1e
+  metadata.gz: 8e46b835cbac5bfe2249537db1825b8cc2402fd8
+  data.tar.gz: ca87915c839fab9bcdbcb011e88fccfecf6c589f
 SHA512:
-  metadata.gz: 02482631941669e1ce796a484b4876e3b9e82dc1a163935579b6ce46acba7a6533ad0b3655df7cb455bec8ac723108ca256c0effb6895a759a584b2e9dd559b4
-  data.tar.gz: 47e7927839f0d30ba4ef9ea11e400b114744d65ade257036d8f018476c17a4ada0bfdaed5c2667d4cd7336987c424d2d298b55717ca5fe8b751ff751b8127023
+  metadata.gz: 1c570b323ea4e9064d50d1d5c9681ce3071e03368b0d094e15d2ab0de838d148c7ccd0f87bd863364b1754743e8f97a9c6c83dff7c4357da4e9d3696e1e0c985
+  data.tar.gz: 33b188c6b3665ca9d0ec98b79c337ae1e5916a624e279aaaab7f0bc2c2320626df876af2837c9106602584ffeaeb8e52cfcef1a69e0013b57b421fe1d78f1e58

data/.travis.yml

@@ -3,4 +3,8 @@ rvm:
   - 2.0.0
   - 2.1
   - 2.2
+  - 2.3.1
   - jruby-19mode
+  - jruby
+before_install:
+  - gem install bundler

data/CHANGES.md

@@ -1,3 +1,10 @@
+# 0.1.0
+
+* Introduce `Uber::Option` as a replacement for `Uber::Options::Value`. It is still there, but deprecated.
+* New API for `Uber::Builder`: You now add builders to `Uber::Builder::Builders` and simply call that instance while passing in context and args. This allows very simple reusable builders that can be used anywhere.
+* `Uber::Options` now uses `Uber::Option`.
+* Removing `Uber::Version` as this is done nicely by `Gem::Version`.
+
 # 0.0.15
 
 * `Value#evaluate` is now `#call`. This will make it easier to introduce Null objects.
@@ -55,4 +62,4 @@
 
 # 0.0.2
 
-* Add `::inheritable_attr`.
+* Add `::inheritable_attr`.

data/Gemfile

@@ -3,4 +3,4 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in uber.gemspec
 gemspec
 
-gem "activesupport"
+gem "benchmark-ips"

data/README.md

@@ -12,7 +12,7 @@ Add this line to your application's Gemfile:
 gem 'uber'
 ```
 
-Ready?
+Uber runs with Ruby >= 1.9.3.
 
 # Inheritable Class Attributes
 
@@ -147,39 +147,61 @@ Note how you simply pass an instance of the callable object into the hash instea
 options = Uber::Options.new(tags: Tags.new)
 ```
 
-## Evaluating Elements
+## Option
 
-If you want to evaluate a single option element, use `#eval`.
+`Uber::Option` implements the pattern of taking an option, such as a proc, instance method name, or static value, and evaluate it at runtime without knowing the option's implementation.
+
+Creating `Option` instances via `::[]` usually happens on class-level in DSL methods.
 
 ```ruby
-options.eval(:ttl, user) #=> "n/a"
+with_proc    = Uber::Option[ ->(options) { "proc: #{options.inspect}" } ]
+with_static  = Uber::Option[ "Static value" ]
+with_method  = Uber::Option[ :name_of_method ]
+
+def name_of_method(options)
+  "method: #{options.inspect}"
+end
 ```
 
-## Single Values
+Use `#call` to evaluate the options at runtime.
 
-Sometimes you don't need an entire hash but a dynamic value, only.
+```ruby
+with_proc.(1, 2)         #=> "proc: [1, 2]"
+with_static.(1, 2)       #=> "Static value"   # arguments are ignored
+with_method.(self, 1, 2) #=> "method: [1, 2]" # first arg is context
+```
+
+It's also possible to evaluate a callable object. It has to be marked with `Uber::Callable` beforehand.
 
 ```ruby
-value = Uber::Options::Value.new(lambda { |volume| volume < 0 ? 0 : volume })
+class MyCallable
+  include Uber::Callable
 
-value.evaluate(context, -122.18) #=> 0
-```
+  def call(context, *args)
+    "callable: #{args.inspect}, #{context}"
+  end
+end
 
-Use `Options::Value#evaluate` to handle single values.
+with_callable = Uber::Option[ MyCallable.new ]
+```
 
-If the `Value` represents a lambda and is `evaluate`d with `nil` as context, the block is called in the original context.
+The context is passed as first argument.
 
 ```ruby
-volume = 99
-value = Uber::Options::Value.new(lambda { volume })
-
-value.evaluate(nil) #=> 99
+with_callable.(Object, 1, 2) #=> "callable: [1, 2] Object"
 ```
 
+You can also make blocks being `instance_exec`ed on the context, giving a unique API to all option types.
 
-## Performance
+```ruby
+with_instance_proc  = Uber::Option[ ->(options) { "proc: #{options.inspect} #{self}" }, instance_exec: true ]
+```
+
+The first argument now becomes the context, exactly the way it works for the method and callable type.
 
-Evaluating an options hash can be time-consuming. When `Options` contains static elements only, it behaves *and performs* like an ordinary hash.
+```ruby
+with_instance_proc.(Object, 1, 2) #=> "proc [1, 2] Object"
+```
 
 
 # Delegates
@@ -216,129 +238,115 @@ song.title #=> "helloween!"
 
 Note how `#title` calls the original title and then downcases the string.
 
-
 # Builder
 
-When included, `Builder` allows to add builder instructions on the class level. These can then be evaluated when instantiating
-the class to conditionally build (sub-)classes based on the incoming parameters.
+Builders are good for polymorphically creating objects without having to know where that happens. You define a builder with conditions in one class, and that class takes care of creating the actual desired class.
 
-Builders can be defined in three different ways.
+## Declarative Interface
+
+Include `Uber::Builder` to leverage the `::builds` method for adding builders, and `::build!` to run those builders in a given context and with arbitrary options.
 
-## Block Syntax
 
 ```ruby
-class Listener
+require "uber/builder"
+
+class User
   include Uber::Builder
 
-  builds do |params|
-    SignedIn if params[:current_user]
+  builds do |options|
+    Admin if params[:admin]
   end
 end
 
-class SignedIn
+class Admin
 end
 ```
 
-The class then has to use the builder to compute a class name using the build blocks you defined.
+Note that you can call `builds` as many times as you want per class.
 
-```ruby
-class Listener
-  def self.build(params)
-    class_builder.call(params).
-    new(params)
-  end
-end
-```
-
-As you can see, it's still up to you to _instantiate_ the object, the builder only helps you computing the concrete class.
+Run the builders using `::build!`.
 
 ```ruby
-Listener.build({}) #=> Listener
-Listener.build({current_user: @current_user}) #=> SignedIn
+User.build!(User, {})              #=> User
+User.build!(User, { admin: true }) #=> Admin
 ```
+The first argument is the context in which the builder blocks will be executed. This is also the default return value if all builders returned a falsey value.
 
-## Proc Syntax
-
-Setting up builders using the proc syntax allows to call `return` in the block. This is our preferred way to define builders.
-
-```ruby
-build ->(params) do
-  return SignedIn if params[:current_user]
-  return Admin    if params[:admin]
-  Default
-end
-```
+All following arguments will be passed straight through to the procs.
 
-This makes the block extremely readable.
+Your API should communicate `User` as the only public class, since the builder hides details about computing the concrete class.
 
-## Method Syntax
+### Builder: Procs
 
-You can also specify a build method.
+You may also use procs instead of blocks.
 
 ```ruby
-build :build_method
+class User
+  include Uber::Builder
 
-def self.build_method(params)
-  return SignedIn if params[:current_user]
+  builds ->(options) do
+    return SignedIn if params[:current_user]
+    return Admin    if params[:admin]
+    Anonymous
+  end
 end
 ```
 
-The method has to be a class method on the building class.
+Note that this allows `return`s in the block.
 
-## Build Context
+## Builder: Direct API
 
-Normally, build blocks and methods are run in the context where they were defined in. You can change that by passing any context object to `class_builder`.
+In case you don't want the `builds` DSL, you can instantiate a `Builders` object yourself and add builders to it using `#<<`.
 
 ```ruby
-def self.build(params)
-  class_builder(context_object) # ...
+MyBuilders = Uber::Builder::Builders.new
+MyBuilders << ->(options) do
+  return Admin if options[:admin]
 end
 ```
 
-This allows copying builders to other classes and evaluate blocks in the new context.
-
-## More On Builders
-
-Note that builders are _not_ inherited to subclasses. This allows instantiating subclasses directly without running builders.
-
-This pattern is used in [Cells](https://github.com/apotonick/cells), [Trailblazer](https://github.com/apotonick/trailblazer) and soon Reform and Representable/Roar, too.
-
-# Version
+Note that you can call `Builders#<<` multiple times per instance.
 
-Writing gems against other gems often involves checking for versions and loading appropriate version strategies - e.g. _"is Rails >= 4.0?"_. Uber gives you `Version` for easy, semantic version deciders.
+Invoke the builder using `#call`.
 
 ```ruby
-version = Uber::Version.new("1.2.3")
+MyBuilders.call(User, {})              #=> User
+MyBuilders.call(User, { admin: true }) #=> Admin
 ```
 
-The API currently gives you `#>=` and `#~`.
+Again, the first object is the context/default return value, all other arguments are passed to the builder procs.
 
-```ruby
-version >= "1.1" #=> true
-version >= "1.3" #=> false
-```
+## Builder: Contexts
 
-The `~` method does a semantic check (currently on major and minor level, only).
+Every proc is `instance_exec`ed in the context you pass into `build!` (or `call`), allowing you to define generic, shareable builders.
 
 ```ruby
-version.~ "1.1" #=> false
-version.~ "1.2" #=> true
-version.~ "1.3" #=> false
-```
+MyBuilders = Uber::Builder::Builders.new
+MyBuilders << ->(options) do
+  return self::Admin if options[:admin] # note the self:: !
+end
 
-Accepting a list of versions, it makes it simple to check for multiple minor versions.
+class User
+  class Admin
+  end
+end
 
-```ruby
-version.~ "1.1", "1.0" #=> false
-version.~ "1.1", "1.2" #=> true
+class Instructor
+  class Admin
+  end
+end
 ```
 
+Now, depending on the context class, the builder will return different classes.
 
-# Undocumented Features
-
-(Please don't read this!)
+```ruby
+MyBuilders.call(User, {})              #=> User
+MyBuilders.call(User, { admin: true }) #=> User::Admin
+MyBuilders.call(Instructor, {})              #=> Instructor
+MyBuilders.call(Instructor, { admin: true }) #=> Instructor::Admin
+```
 
-* You can enforce treating values as dynamic (or not): `Uber::Options::Value.new("time_to_live", dynamic: true)` will always run `#time_to_live` as an instance method on the context, even though it is not a symbol.
+Don't forget the `self::` when writing generic builders, and write tests.
 
 # License
 

data/lib/uber/builder.rb

@@ -1,97 +1,41 @@
-require "uber/options"
+require "uber/option"
 
 module Uber
-  # When included, allows to add builder on the class level.
-  #
-  #   class Operation
-  #     include Uber::Builder
-  #
-  #     builds do |params|
-  #       SignedIn if params[:current_user]
-  #     end
-  #
-  #     class SignedIn
-  #     end
-  #
-  # The class then has to call the builder to compute a class name using the build blocks you defined.
-  #
-  #     def self.build(params)
-  #       class_builder.call(params).
-  #       new(params)
-  #     end
   module Builder
     def self.included(base)
-      base.class_eval do
-        def self.builders
-          @builders ||= []
-        end
-
-        extend ClassMethods
-      end
+      base.extend DSL
+      base.extend Build
     end
 
-    # Computes the concrete target class.
-    class Constant
-      def initialize(constant, context)
-        @constant     = constant
-        @context      = context
-        @builders     = @constant.builders # only dependency, must be a Cell::Base subclass.
-      end
+    class Builders < Array
+      def call(context, *args)
+        each do |block|
+          klass = block.(context, *args) and return klass # Uber::Value#call()
+        end
 
-      def call(*args)
-        build_class_for(*args)
+        context
       end
 
-    private
-      def build_class_for(*args)
-        @builders.each do |blk|
-          klass = run_builder_block(blk, *args) and return klass
-        end
-        @constant
+      def <<(proc)
+        super Uber::Option[proc, instance_exec: true]
       end
+    end
 
-      def run_builder_block(block, *args)
-        block.(@context, *args) # Uber::Value.call()
+    module DSL
+      def builders
+        @builders ||= Builders.new
       end
-    end
 
-    module ClassMethods
-      # Adds a builder to the cell class. Builders are used in #cell to find out the concrete
-      # class for rendering. This is helpful if you frequently want to render subclasses according
-      # to different circumstances (e.g. login situations) and you don't want to place these deciders in
-      # your view code.
-      #
-      # Passes the model and options from #cell into the block.
-      #
-      # Multiple build blocks are ORed, if no builder matches the building cell is used.
-      #
-      # Example:
-      #
-      # Consider two different user box cells in your app.
-      #
-      #   class AuthorizedUserBox < UserInfoBox
-      #   end
-      #
-      #   class AdminUserBox < UserInfoBox
-      #   end
-      #
-      # Now you don't want to have deciders all over your views - use a declarative builder.
-      #
-      #   UserInfoBox.build do |model, options|
-      #     AuthorizedUserBox if options[:is_signed_in]
-      #     AdminUserBox if model.admin?
-      #   end
-      #
-      # In your view #cell will instantiate the right class for you now.
       def builds(proc=nil, &block)
-        builders << Uber::Options::Value.new(proc.nil? ? block : proc) # TODO: provide that in Uber::O:Value.
+        builders << (proc || block)
       end
+    end
 
-      # Call this from your classes' own ::build method to compute the concrete target class.
-      # The class_builder is cached, you can't change the context once it's set.
-      def class_builder(context=nil)
-        @class_builder ||= Constant.new(self, context)
+    module Build
+      # Call this from your class to compute the concrete target class.
+      def build!(context, *args)
+        builders.(context, *args)
       end
-    end # ClassMethods
+    end
   end
 end

data/lib/uber/inheritable_attr.rb

@@ -2,7 +2,7 @@ module Uber
   module InheritableAttr
 
     def inheritable_attr(name, options={})
-      instance_eval %Q{
+      instance_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{name}=(v)
           @#{name} = v
         end
@@ -11,7 +11,7 @@ module Uber
           return @#{name} if instance_variable_defined?(:@#{name})
           @#{name} = InheritableAttribute.inherit_for(self, :#{name}, #{options})
         end
-      }
+      RUBY
     end
 
     def self.inherit_for(klass, name, options={})

data/lib/uber/option.rb

@@ -0,0 +1,16 @@
+require "uber/callable"
+
+module Uber
+  class Option
+    def self.[](value, options={}) # TODO: instance_exec: true
+      if value.is_a?(Proc)
+        return ->(context, *args) { context.instance_exec(*args, &value) } if options[:instance_exec]
+        return value
+      end
+
+      return value                                            if value.is_a?(Uber::Callable)
+      return ->(context, *args){ context.send(value, *args) } if value.is_a?(Symbol)
+      ->(*) { value }
+    end
+  end
+end

data/lib/uber/options.rb

@@ -1,4 +1,5 @@
-require 'uber/callable'
+require "uber/callable"
+require "uber/option"
 
 module Uber
   class Options < Hash
@@ -6,41 +7,27 @@ module Uber
       @static = options
 
       options.each do |k,v|
-        self[k] = option = Value.new(v)
-        @static = nil if option.dynamic?
+        self[k] = Option[v, instance_exec: true]
       end
     end
 
-    #   1.100000   0.060000   1.160000 (  1.159762) original
-    #   0.120000   0.010000   0.130000 (  0.135803) return self
-    #   0.930000   0.060000   0.990000 (  0.997095) without v.evaluate
-
     # Evaluates every element and returns a hash.  Accepts context and arbitrary arguments.
     def evaluate(context, *args)
-      return @static unless dynamic?
-
-      evaluate_for(context, *args)
-    end
-
-    # Evaluates a single value.
-    def eval(key, *args)
-      self[key].evaluate(*args)
-    end
-
-  private
-    def evaluate_for(context, *args)
       {}.tap do |evaluated|
         each do |k,v|
-          evaluated[k] = v.evaluate(context, *args)
+          evaluated[k] = v.(context, *args)
         end
       end
     end
 
-    def dynamic?
-      not @static
+    # Evaluates a single value.
+    def eval(key, *args)
+      self[key].(*args)
     end
 
+  private
 
+    # DEPRECATED! PLEASE USE UBER::OPTION.
     class Value # TODO: rename to Value.
       def initialize(value, options={})
         @value, @dynamic = value, options[:dynamic]
@@ -103,4 +90,4 @@ module Uber
       end
     end
   end
-end
+end

data/lib/uber/version.rb

@@ -1,33 +1,3 @@
 module Uber
-  class Version < Hash
-    def initialize(version)
-      @version = Gem::Version.new(version)
-      major, minor, patch = @version.segments
-
-      self[:major] = major || 0
-      self[:minor] = minor || 0
-      self[:patch] = patch || 0
-    end
-
-    def >=(version)
-      major, minor, patch = parse(version)
-
-      self[:major] > major or
-        (self[:major] == major and self[:minor] >= minor and self[:patch] >= patch)
-    end
-
-    def ~(*versions)
-      !! versions.find do |v|
-        major, minor, patch = parse(v)
-
-        self[:major] == major and self[:minor] == minor
-      end
-    end
-
-  private
-    def parse(version)
-      major, minor, patch = Gem::Version.new(version).segments
-      [major||0, minor||0, patch||0]
-    end
-  end
-end
+  VERSION = "0.1.0"
+end

data/test/builder-benchmark.rb

@@ -0,0 +1,17 @@
+require "test_helper"
+require "uber/options"
+require "uber/option"
+require "benchmark/ips"
+
+proc = ->(options) { "great" }
+
+value  = Uber::Options::Value.new(proc)
+option = Uber::Option[proc, instance_exec: true]
+
+Benchmark.ips do |x|
+  x.report(:value)  { value.(self, {}) }
+  x.report(:option) { option.(self, {}) }
+end
+
+#  value    946.110k (± 2.4%) i/s -      4.766M in   5.040395s
+# option      1.583M (± 1.6%) i/s -      7.928M in   5.009953s

data/test/builder_test.rb

@@ -17,7 +17,7 @@ class BuilderTest < MiniTest::Spec
     end
 
     def self.build(options)
-      class_builder.call(options).new
+      build!(self, options).new
     end
   end
 
@@ -40,7 +40,7 @@ class BuilderTest < MiniTest::Spec
     end
 
     def self.build(options)
-      class_builder.call(options).new
+      build!(self, options).new
     end
   end
 
@@ -66,7 +66,7 @@ class BuilderTest < MiniTest::Spec
     end
 
     def self.build(options)
-      class_builder.call(options).new
+      build!(self, options).new
     end
   end
 
@@ -94,10 +94,17 @@ class BuilderScopeTest < MiniTest::Spec
     end
 
     def self.build(context, options={})
-      class_builder(context).call(options)
+      build!(context, options)
     end
   end
 
+  it do
+    Song.build(self.class).must_equal BuilderScopeTest::Hit
+
+    # this runs BuilderScopeTest::builder_method and returns self.
+    Song.build(self.class, from_builder_method: true).must_equal BuilderScopeTest
+  end
+
   class Evergreen
     class Hit
     end
@@ -110,7 +117,7 @@ class BuilderScopeTest < MiniTest::Spec
     self.builders = Song.builders
 
     def self.build(context, options={})
-      class_builder(context).call(options)
+      build!(context, options)
     end
 
     def self.builder_method(options)
@@ -118,21 +125,23 @@ class BuilderScopeTest < MiniTest::Spec
     end
   end
 
-  it do
-    Song.build(self.class).must_equal BuilderScopeTest::Hit
-
-    # this runs BuilderScopeTest::builder_method and returns self.
-    Song.build(self.class, from_builder_method: true).must_equal BuilderScopeTest
-
-    # since the class_builder gets cached, this won't change.
-    Song.build(Song).must_equal BuilderScopeTest::Hit
-  end
-
-
   it do
     # running the "copied" block in Evergreen will reference the correct @context.
     Evergreen.build(Evergreen).must_equal BuilderScopeTest::Evergreen::Hit
 
     Evergreen.build(Evergreen, from_builder_method: true).must_equal BuilderScopeTest::Evergreen
   end
-end
+
+  #---
+  # Builders API
+  # Builders#call
+  # Builders#<<
+  A = Class.new
+  MyBuilders = Uber::Builder::Builders.new
+  MyBuilders << ->(options) do
+    return Song if options[:hit]
+  end
+
+  it { MyBuilders.call(A, {}).new.must_be_instance_of A }
+  it { MyBuilders.call(A, { hit: true }).new.must_be_instance_of Song }
+end

data/test/option_test.rb

@@ -0,0 +1,47 @@
+require "test_helper"
+require "uber/option"
+
+class OptionTest < Minitest::Spec
+  Option = Uber::Option
+
+  # proc
+  it { Option[ ->(*args) { "proc! #{args.inspect}" } ].(1,2).must_equal "proc! [1, 2]" }
+  it { Option[ lambda { "proc!" } ].().must_equal "proc!" }
+
+  # proc with instance_exec
+  it { Option[ ->(*args) { "#{self.class} #{args.inspect}" } ].(Object, 1, 2).must_equal "OptionTest [Object, 1, 2]" }
+  it { Option[ ->(*args) { "#{self} #{args.inspect}" }, instance_exec: true ].(Object, 1, 2).must_equal "Object [1, 2]" }
+
+  # static
+  it { Option[true].().must_equal true }
+  it { Option[nil].().must_equal nil }
+  it { Option[false].().must_equal false }
+  # args are ignored.
+  it { Option[true].(1,2,3).must_equal true }
+
+  # instance method
+  class Hello
+    def hello(*args); "Hello! #{args.inspect}" end
+  end
+  it { Option[:hello].(Hello.new).must_equal "Hello! []" }
+  it { Option[:hello].(Hello.new, 1, 2).must_equal "Hello! [1, 2]" }
+
+  #---
+  # Callable
+  class Callio
+    include Uber::Callable
+    def call(); "callable!" end
+  end
+
+  it { Option[Callio.new].().must_equal "callable!" }
+end
+
+# require "benchmark/ips"
+
+# method = Uber::Option[->(context, options) { context }]
+# proc = Uber::Option[A.new { |context, options| context }]
+
+# Benchmark.ips do |x|
+#   x.report(:method) { method.(Object, {}) }
+#   x.report(:proc)   { proc.(Object, {}) }
+# end

data/test/options_test.rb

@@ -1,96 +1,12 @@
 require 'test_helper'
 require 'uber/options'
 
-class UberOptionTest < MiniTest::Spec
-  Value = Uber::Options::Value
-  let (:object) { Object.new }
-
-  class Callable
-    include Uber::Callable
-    def call(*); 999 end
-  end
-
-  describe "#dynamic?" do
-    it { Value.new(1).dynamic?.must_equal false }
-    it { Value.new(true).dynamic?.must_equal false }
-    it { Value.new("loud").dynamic?.must_equal false }
-    it { Value.new(:loud, :dynamic => false).dynamic?.must_equal false }
-    it { Value.new("loud", :dynamic => true).dynamic?.must_equal true }
-
-    it { Value.new(lambda {}).dynamic?.must_equal true }
-    it { Value.new(Proc.new{}).dynamic?.must_equal true }
-    it { Value.new(:method).dynamic?.must_equal true }
-
-    # Uber::Callable
-    it { Value.new(Callable.new).dynamic?.must_equal true }
-  end
-
-  describe "#call" do
-    let (:version) { Module.new { def version; 999 end } }
-
-    it { Value.new(nil).(Object.new).must_equal nil }
-    # it { Value.new(nil, :dynamic => true).(Object.new).must_equal nil } # DISCUSS: should we handle that?
-
-    it { Value.new(true).(Object.new).must_equal true }
-
-    it { Value.new(:version).(object.extend(version)).must_equal 999 }
-    it { Value.new("version", :dynamic => true).(object.extend(version)).must_equal 999 }
-    it { Value.new(:version, :dynamic => false).(object.extend(version)).must_equal :version }
-    it { Value.new(lambda { self }).(object).must_equal object }
-    it { Value.new(lambda { self }).(nil).must_equal self }
-
-    it { Value.new(lambda { :loud }, :dynamic => true).(object).must_equal :loud }
-
-    # Uber::Callable
-    it { Value.new(Callable.new).(nil).must_equal 999 }
-  end
-
-  it "#call is aliased to evaluate" do
-    Value.new(Callable.new).(nil).must_equal 999
-  end
-
-  describe "passing options" do
-    let (:version) { Module.new { def version(*args); args.inspect end } }
-    let (:block) { Proc.new { |*args| args.inspect } }
-    let (:callable) { (Class.new { include Uber::Callable; def call(*args); args.inspect; end }).new }
-
-    it { Value.new(:version).(object.extend(version), 1, 2, 3).must_equal "[1, 2, 3]" }
-    it { Value.new(block).(object, 1, 2, 3).must_equal "[1, 2, 3]" }
-    it { Value.new(callable).(Object, 1, 2, 3).must_equal "[Object, 1, 2, 3]" }
-  end
-
-  # it "speed" do
-  #   require "benchmark"
-
-  #   options = 1000000.times.collect do
-  #     Uber::Options.new(expires: false)
-  #   end
-
-  #   time = Benchmark.measure do
-  #     options.each do |opt|
-  #       opt.evaluate(nil)
-  #     end
-  #   end
-
-  #   puts "good results"
-  #   puts time
-  # end
-end
-
-# TODO: test passing arguments to block and method optionally.
-
 class UberOptionsTest < MiniTest::Spec
   Options = Uber::Options
 
   let (:dynamic) { Options.new(:volume =>1, :style => "Punkrock", :track => Proc.new { |i| i.to_s }) }
 
-  describe "#dynamic?" do
-    it { Options.new(:volume =>1, :style => "Punkrock").send(:dynamic?).must_equal false }
-    it { Options.new(:style => Proc.new{}, :volume =>1).send(:dynamic?).must_equal true }
-  end
-
   describe "#evaluate" do
-
     it { dynamic.evaluate(Object.new, 999).must_equal({:volume =>1, :style => "Punkrock", :track => "999"}) }
 
     describe "static" do
@@ -114,4 +30,4 @@ class UberOptionsTest < MiniTest::Spec
     it { dynamic.eval(:style, 999).must_equal "Punkrock" }
     it { dynamic.eval(:track, Object.new, 999).must_equal "999" }
   end
-end
+end

data/uber.gemspec

@@ -1,11 +1,11 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../lib/uber/uber_version', __FILE__)
+require File.expand_path('../lib/uber/version', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.authors       = ["Nick Sutterer"]
   gem.email         = ["apotonick@gmail.com"]
   gem.description   = %q{A gem-authoring framework.}
-  gem.summary       = %q{Gem-authoring tools like class method inheritance in modules, dynamic options and more.}
+  gem.summary       = %q{Gem-authoring tools like generic builders, dynamic options and more.}
   gem.homepage      = "https://github.com/apotonick/uber"
   gem.license       = "MIT"
 
@@ -16,6 +16,6 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Uber::VERSION
 
-  gem.add_development_dependency "rake",      ">= 0.10.1"
-  gem.add_development_dependency "minitest",  ">= 5.0.0"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "minitest"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uber
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.1.0
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-01 00:00:00.000000000 Z
+date: 2016-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.1
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.1
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: '0'
 description: A gem-authoring framework.
 email:
 - apotonick@gmail.com
@@ -57,16 +57,17 @@ files:
 - lib/uber/callable.rb
 - lib/uber/delegates.rb
 - lib/uber/inheritable_attr.rb
+- lib/uber/option.rb
 - lib/uber/options.rb
-- lib/uber/uber_version.rb
 - lib/uber/version.rb
+- test/builder-benchmark.rb
 - test/builder_test.rb
 - test/delegates_test.rb
 - test/inheritable_attr_test.rb
 - test/inheritance_test.rb
+- test/option_test.rb
 - test/options_test.rb
 - test/test_helper.rb
-- test/version_test.rb
 - test/zeugs.rb
 - uber.gemspec
 homepage: https://github.com/apotonick/uber
@@ -89,18 +90,17 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.6.3
 signing_key: 
 specification_version: 4
-summary: Gem-authoring tools like class method inheritance in modules, dynamic options
-  and more.
+summary: Gem-authoring tools like generic builders, dynamic options and more.
 test_files:
+- test/builder-benchmark.rb
 - test/builder_test.rb
 - test/delegates_test.rb
 - test/inheritable_attr_test.rb
 - test/inheritance_test.rb
+- test/option_test.rb
 - test/options_test.rb
 - test/test_helper.rb
-- test/version_test.rb
 - test/zeugs.rb
-has_rdoc: 

data/lib/uber/uber_version.rb

@@ -1,3 +0,0 @@
-module Uber
-  VERSION = "0.0.15"
-end

data/test/version_test.rb

@@ -1,27 +0,0 @@
-require 'test_helper'
-
-
-class VersionTest < MiniTest::Spec
-    subject { Uber::Version.new("1.2.3") } # Rails version
-
-    it { subject.~("1.0").must_equal false }
-    it { subject.~("1.1").must_equal false }
-    it { subject.~("1.2").must_equal true }
-    it { subject.~("1.3").must_equal false }
-    it { subject.~("2.2").must_equal false }
-    it { subject.~("1.0", "1.1").must_equal false }
-    it { subject.~("1.0", "1.1", "1.2").must_equal true }
-    it { subject.~("1.2", "1.3").must_equal true }
-
-    it { (subject >= "1.2.4").must_equal false }
-    it { (subject >= "1.2.2").must_equal true }
-    it { (subject >= "0.3.1").must_equal true }
-    it { (subject >= "0.3.6").must_equal true }
-    it { (subject >= "0.3").must_equal true }
-    it { (subject >= "0.2.4").must_equal true }
-    it { (subject >= "0.2").must_equal true }
-    it { (subject >= "1.2").must_equal true }
-    it { (subject >= "1.1").must_equal true }
-    it { (subject >= "1.3").must_equal false }
-    it { (subject >= "2.1").must_equal false }
-end