uber 0.0.1 → 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 58b218477b8c36e49f66c8bd47175bf605613ef1
+  data.tar.gz: bde8206f4395aa6469f9dfe84eb3651449acd0e3
+SHA512:
+  metadata.gz: f08f9af53d76f9800741b6eacd147d031a356b40e309172c1323cf5a80b2f1f70271c1f383f7fbcb2681ac72eaf163b64fc364a36888523688cbbb8147185d22
+  data.tar.gz: 8b6a3e28f375e50b829fe60bf5a2a5ab50daafee28cd5e6334d8488e201b85a12ed915ed0e3c1c84938f5006f5ec55a8b1be07141895bdecc8472c24bfa8348e

data/CHANGES.md

@@ -0,0 +1,3 @@
+# 0.0.2
+
+* Add `::inheritable_attr`.

data/Gemfile

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

data/README.md

@@ -1,6 +1,6 @@
 # Uber
 
-TODO: Write a gem description
+_Gem-authoring tools like class method inheritance in modules, dynamic options and more._
 
 ## Installation
 
@@ -8,22 +8,70 @@ Add this line to your application's Gemfile:
 
     gem 'uber'
 
-And then execute:
+Ready?
 
-    $ bundle
+# Inheritable Class Attributes
 
-Or install it yourself as:
+This is for you if you want class attributes to be inherited, which is a mandatory mechanism for creating DSLs.
 
-    $ gem install uber
+```ruby
+require 'uber/inheritable_attr'
 
-## Usage
+class Song
+  extend Uber::InheritableAttr
 
-TODO: Write usage instructions here
+  inheritable_attr :properties
+  self.properties = [:title, :track] # initialize it before using it.
+end
+```
 
-## Contributing
+Note that you have to initialize your attribute which whatever you want - usually a hash or an array.
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+You can now use that attribute on the class level.
+
+```ruby
+Song.properties #=> [:title, :track]
+```
+
+Inheriting from `Song` will result in the `properties` object being `clone`d to the sub-class.
+
+```ruby
+class Hit < Song
+end
+
+Hit.properties #=> [:title, :track]
+```
+
+The cool thing about the inheritance is: you can work on the inherited attribute without any restrictions, as it is a _copy_ of the original.
+
+```ruby
+Hit.properties << :number
+
+Hit.properties  #=> [:title, :track, :number]
+Song.properties #=> [:title, :track]
+```
+
+It's similar to ActiveSupport's `class_attribute` but with a simpler implementation resulting in a less dangerous potential. Also, there is no restriction about the way you modify the attribute [as found in `class_attribute`](http://apidock.com/rails/v4.0.2/Class/class_attribute).
+
+This module is very popular amongst numerous gems like Cells, Representable, Roar and Reform.
+
+
+# Options
+
+Implements the pattern of defining configuration options and evaluating them at run-time.
+
+Usually DSL methods accept a number of options that can either be static values, instance method names as symbols, or blocks (lambdas/Procs).
+
+Uber::Options.new volume: 9, track: lambda { |s| s.track }
+
+
+Note that `Options` behaves *and performs* like an ordinary hash when all options are static.
+
+only use for declarative assets, not at runtime (use a hash)
+
+
+# License
+
+Copyright (c) 2014 by Nick Sutterer <apotonick@gmail.com>
+
+Roar is released under the [MIT License](http://www.opensource.org/licenses/MIT).

data/lib/uber/inheritable_attr.rb

@@ -0,0 +1,22 @@
+module Uber
+  module InheritableAttr
+    def inheritable_attr(name)
+      instance_eval %Q{
+        def #{name}=(v)
+          @#{name} = v
+        end
+
+        def #{name}
+          @#{name} ||= InheritableAttribute.inherit_for(self, :#{name})
+        end
+      }
+    end
+
+    def self.inherit_for(klass, name)
+      return unless klass.superclass.respond_to?(name) and value = klass.superclass.send(name)
+      value.clone # only do this once.
+    end
+  end
+
+  InheritableAttribute = InheritableAttr
+end

data/lib/uber/options.rb

@@ -0,0 +1,70 @@
+module Uber
+  class Options < Hash
+    def initialize(options)
+      @static = options
+
+      options.each do |k,v|
+        self[k] = option = Value.new(v)
+        @static = nil if option.dynamic?
+      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)
+        end
+      end
+    end
+
+    def dynamic?
+      not @static
+    end
+
+
+    class Value # TODO: rename to Value.
+      def initialize(value, options={})
+        @value = value || true
+        @options = options
+      end
+
+      def evaluate(context, *args)
+        return true if @value.is_a?(TrueClass)
+
+        evaluate_for(context, *args)
+      end
+
+      def dynamic?
+        @options[:instance_method] || @value.kind_of?(Proc)
+      end
+
+    private
+      def evaluate_for(context, *args)
+        return proc!(context, *args) unless @value.kind_of?(Proc)
+        @value.call(context, *args) # TODO: change to context.instance_exec and deprecate first argument.
+      end
+
+      def proc!(context, *args)
+        return context.send(@value, *args) if @options[:instance_method]
+        @value
+      end
+    end
+  end
+end

data/lib/uber/version.rb

@@ -1,3 +1,3 @@
 module Uber
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/inheritable_attr_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+require "uber/inheritable_attr"
+
+class InheritableAttrTest < MiniTest::Spec
+  describe "::inheritable_attr" do
+    subject {
+      Class.new(Object) do
+        extend Uber::InheritableAttribute
+        inheritable_attr :drinks
+      end
+    }
+
+    it "provides a reader with empty inherited attributes, already" do
+      assert_equal nil, subject.drinks
+    end
+
+    it "provides a reader with empty inherited attributes in a derived class" do
+      assert_equal nil, Class.new(subject).drinks
+      #subject.drinks = true
+      #Class.new(subject).drinks # TODO: crashes.
+    end
+
+    it "provides an attribute copy in subclasses" do
+      subject.drinks = []
+      assert subject.drinks.object_id != Class.new(subject).drinks.object_id
+    end
+
+    it "provides a writer" do
+      subject.drinks = [:cabernet]
+      assert_equal [:cabernet], subject.drinks
+    end
+
+    it "inherits attributes" do
+      subject.drinks = [:cabernet]
+
+      subklass_a = Class.new(subject)
+      subklass_a.drinks << :becks
+
+      subklass_b = Class.new(subject)
+
+      assert_equal [:cabernet],         subject.drinks
+      assert_equal [:cabernet, :becks], subklass_a.drinks
+      assert_equal [:cabernet],         subklass_b.drinks
+    end
+
+    it "does not inherit attributes if we set explicitely" do
+      subject.drinks = [:cabernet]
+      subklass = Class.new(subject)
+
+      subklass.drinks = [:merlot] # we only want merlot explicitely.
+      assert_equal [:merlot], subklass.drinks # no :cabernet, here
+    end
+  end
+end

data/test/inheritance_test.rb

@@ -1,7 +1,52 @@
 require 'test_helper'
+require 'uber/inheritable_included'
+
+module InheritIncludedTo
+  def self.call(includer, proc)
+    proc.call(includer) # das will ich eigentlich machen
+
+    includer.class_eval do
+      @block = proc
+
+      def self.included(base) #
+        InheritIncludedTo.call(base, instance_variable_get(:@block))
+      end
+    end
+  end
+end
 
 class InheritanceTest < MiniTest::Spec
-  describe "including" do
-    
+  module Feature
+    #extend Uber::InheritedIncluded
+
+    CODE_BLOCK = lambda { |base| base.class_eval { extend ClassMethods } } # i want that to be executed at every include
+
+
+    def self.included(includer) #
+      # CODE_BLOCK.call(base)
+      InheritIncludedTo.call(includer, CODE_BLOCK)
+    end
+
+    module ClassMethods
+      def feature; end
+    end
   end
+
+  module Extension
+    include Feature
+
+    # TODO: test overriding ::included
+  end
+
+  module Client
+    include Extension
+  end
+
+  module ExtendedClient
+    include Client
+  end
+
+  it { Extension.must_respond_to :feature }
+  it { Client.must_respond_to :feature }
+  it { ExtendedClient.must_respond_to :feature }
 end

data/test/options_test.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+require 'uber/options'
+
+class UberOptionTest < MiniTest::Spec
+  Value = Uber::Options::Value
+
+  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(lambda {}).dynamic?.must_equal true }
+    it { Value.new(Proc.new{}).dynamic?.must_equal true }
+    it { Value.new(:method, :instance_method => true).dynamic?.must_equal true }
+  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
+
+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(999).must_equal({:volume =>1, :style => "Punkrock", :track => "999"}) }
+
+    describe "static" do
+      let (:static) { Options.new(:volume =>1, :style => "Punkrock") }
+
+      it { static.evaluate(nil).must_equal({:volume =>1, :style => "Punkrock"}) }
+
+      it "doesn't evaluate internally" do
+        static.instance_eval do
+          def evaluate_for(*)
+            raise "i shouldn't be called!"
+          end
+        end
+        static.evaluate(nil).must_equal({:volume =>1, :style => "Punkrock"})
+      end
+    end
+  end
+
+  describe "#eval" do
+    it { dynamic.eval(:volume, 999).must_equal 1 }
+    it { dynamic.eval(:style, 999).must_equal "Punkrock" }
+    it { dynamic.eval(:track, 999).must_equal "999" }
+  end
+end

data/test/test_helper.rb

@@ -1,8 +1,5 @@
 require 'bundler'
 Bundler.setup
 
-gem 'minitest'
-require 'minitest/spec'
 require 'minitest/autorun'
-
 require 'uber'

data/test/zeugs.rb

@@ -0,0 +1,54 @@
+module Feature
+  module ClassMethods
+    def feature
+    end
+  end
+
+  # in uber, this would look somehow like
+  # module Feature
+  #   module ClassMethods ... end
+
+  #   extend Uber::InheritableIncluded
+  #   inheritable_included do |includer|
+  #     includer.extend ClassMethods
+  #   end
+  # end
+
+  InheritedIncludedCodeBlock = lambda do |includer|
+    includer.extend ClassMethods
+  end
+
+  module RecursiveIncluded
+    def included(includer)
+      #super # TODO: test me.
+      puts "RecursiveIncluded in #{includer}"
+
+      includer.module_eval do
+        InheritedIncludedCodeBlock.call(includer)
+        extend RecursiveIncluded
+      end
+    end
+  end
+  extend RecursiveIncluded
+end
+
+module Client
+  include Feature
+end
+
+module Extension
+  include Client
+end
+
+module Plugin
+  include Extension
+end
+
+module Framework
+  include Plugin
+end
+
+Client.feature
+Extension.feature
+Plugin.feature
+Framework.feature

data/uber.gemspec

@@ -5,7 +5,7 @@ Gem::Specification.new do |gem|
   gem.authors       = ["Nick Sutterer"]
   gem.email         = ["apotonick@gmail.com"]
   gem.description   = %q{A gem-authoring framework.}
-  gem.summary       = %q{Uber is a gem-authoring framework that brings simple module inheritance and more.}
+  gem.summary       = %q{Gem-authoring tools like class method inheritance in modules, dynamic options and more.}
   gem.homepage      = ""
 
   gem.files         = `git ls-files`.split($\)
@@ -14,6 +14,7 @@ Gem::Specification.new do |gem|
   gem.name          = "uber"
   gem.require_paths = ["lib"]
   gem.version       = Uber::VERSION
-  
-  gem.add_development_dependency "minitest", ">= 2.8.1"
+
+  gem.add_development_dependency "rake",      ">= 0.10.1"
+  gem.add_development_dependency "minitest",  ">= 5.0.0"
 end

metadata

@@ -1,32 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: uber
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 0.0.2
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-07 00:00:00.000000000 Z
+date: 2014-03-06 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.1
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.8.1
+        version: 5.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.8.1
+        version: 5.0.0
 description: A gem-authoring framework.
 email:
 - apotonick@gmail.com
@@ -34,41 +45,49 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
+- CHANGES.md
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - lib/uber.rb
+- lib/uber/inheritable_attr.rb
+- lib/uber/options.rb
 - lib/uber/version.rb
+- test/inheritable_attr_test.rb
 - test/inheritance_test.rb
+- test/options_test.rb
 - test/test_helper.rb
+- test/zeugs.rb
 - uber.gemspec
 homepage: ''
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.2.1
 signing_key: 
-specification_version: 3
-summary: Uber is a gem-authoring framework that brings simple module inheritance and
-  more.
+specification_version: 4
+summary: Gem-authoring tools like class method inheritance in modules, dynamic options
+  and more.
 test_files:
+- test/inheritable_attr_test.rb
 - test/inheritance_test.rb
+- test/options_test.rb
 - test/test_helper.rb
+- test/zeugs.rb