rol 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c9a583889c5bb1db7b14ba7eb318f87c2e3809ce
+  data.tar.gz: b918dfbaf8df2905800f05a2fdc4de9ef051a925
+SHA512:
+  metadata.gz: e38eaca339fb517cd58a5691a59a287846b6c2d4676a3da50e8a6d3c087b35ce91bd12088759f8f159a2f277960d27ea1936ab19243b6f38609521bf005c81a7
+  data.tar.gz: 10122bd637c9cc64c52621b1cf92fd7e7d673af44bb768e9681673d8ea53af181bac05f996ed15b52aaeeae5920bf22d97ed6c9f916075f2556572383dddbd0e

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Michael Lewandowski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/lib/rol.rb

@@ -0,0 +1,121 @@
+#
+# 'require' all files except ourselves.
+#
+me = File.absolute_path(__FILE__)
+Dir.glob(File.dirname(me) + '/**/*.rb') {|fn| require fn unless fn == me }
+
+
+#
+# Module Rol (Ruby object literal) provides the utility method rol() that
+# creates an object instance from a hash, similar to the way objects can
+# created in JavaScript.
+#
+module Rol
+  def self.rol(hash = {})
+    check_arg(hash)
+    build_object(hash)
+  end
+
+  private
+
+  def self.check_arg(hash)
+    raise_not_a_hash_argument_error unless hash.respond_to?(:each_pair)
+  end
+
+  def self.raise_not_a_hash_argument_error
+    raise ArgumentError.new("rol(hash): 'hash' argument must respond to #each_pair")
+  end
+
+  def self.build_object(hash)
+    object = Object.new
+    add_members(object, hash)
+    object
+  end
+
+  def self.add_members(object, hash)
+    hash.each_pair { |name, value| add_member(object, name, value) }
+  end
+
+  def self.add_member(object, name, value)
+    if value.is_a? Proc
+      add_method_member(object, name, value)
+    else
+      add_attribute_member(object, name, value)
+    end
+  end
+
+  #
+  # def object.my_method(arg1, arg2, ...)
+  #   ...
+  # end
+  #
+  def self.add_method_member(object, method_name, proc)
+    object.define_singleton_method(method_name) do |*args|
+      object.instance_exec(*args, &proc)
+    end
+  end
+
+  #
+  # def object.my_attribute
+  #   @my_attribute
+  # end
+  #
+  # def object.my_attribute=(value)
+  #   @my_attribute = value
+  # end
+  #
+  # object.my_attribute = initial_value
+  #
+  def self.add_attribute_member(object, attribute_name, initial_value)
+    check_attribute_name(attribute_name)
+    instance_variable_name = build_instance_variable_name(attribute_name)
+    add_attribute_getter_method(object, attribute_name, instance_variable_name)
+    add_attribute_setter_method(object, attribute_name, instance_variable_name)
+    initialize_attribute(object, instance_variable_name, initial_value)
+  end
+
+  def self.check_attribute_name(attribute_name)
+    raise_ends_with_equals_argument_error(attribute_name) if attribute_name.to_s.end_with?('=')
+  end
+
+  def self.raise_ends_with_equals_argument_error(attribute_name)
+    raise ArgumentError.new("rol(hash): attribute name '#{attribute_name}' must not end with =")
+  end
+
+  #
+  # 'my_attribute' => :@my_attribute
+  #
+  def self.build_instance_variable_name(attribute_name)
+    "@#{attribute_name}".to_sym
+  end
+
+  #
+  # def object.my_attribute
+  #   @my_attribute
+  # end
+  #
+  def self.add_attribute_getter_method(object, attribute_name, instance_variable_name)
+    object.define_singleton_method(attribute_name) do
+      instance_variable_get(instance_variable_name)
+    end
+  end
+
+  #
+  # def object.my_attribute=(value)
+  #   @my_attribute = value
+  # end
+  #
+  def self.add_attribute_setter_method(object, attribute_name, instance_variable_name)
+    method_name = "#{attribute_name}="
+    object.define_singleton_method(method_name) do |value|
+      instance_variable_set(instance_variable_name, value)
+    end
+  end
+
+  #
+  # object.my_attribute = initial_value
+  #
+  def self.initialize_attribute(object, instance_variable_name, initial_value)
+    object.instance_variable_set(instance_variable_name, initial_value)
+  end
+end

data/lib/rol/kernel.rb

@@ -0,0 +1,8 @@
+#
+# Save some typing by making rol() syntactic sugar for Rol.rol()
+#
+module Kernel
+  def rol(*args)
+    Rol.rol(*args)
+  end
+end

data/lib/rol/version.rb

@@ -0,0 +1,3 @@
+module Rol
+  Version = "0.0.1"
+end

data/test/rol/rol_test.rb

@@ -0,0 +1,224 @@
+require_relative '../test_helper'
+
+
+#
+# In the various tests below, we add various methods to an instance
+# of Object.  Here we ensure Object does not already have those
+# methods.
+#
+describe 'assumptions about Object' do
+  [ :name, :greet, :x, :Capitalized, :first, :second, :third, :my_method, :height, :width, :area ].each do |name|
+    it "does not have an attribute called :#{name}" do
+      Object.new.instance_variables.wont_include name
+    end
+    it "does not have a method called :#{name}" do
+      Object.new.methods.wont_include name
+    end
+    it "does not have a method called :#{name}=" do
+      Object.new.methods.wont_include "#{name}=".to_sym
+    end
+  end
+end
+
+
+#
+# What does rol do?
+#
+describe 'rol()' do
+  it 'provides a shorthand way to create an object on the fly' do
+    object = rol({
+      name: 'Fluffy',
+      greet: -> (your_name) { "Hi #{your_name}! My name is #{@name}!" }
+    })
+    object.greet('Spot').must_equal 'Hi Spot! My name is Fluffy!'
+  end
+end
+
+
+#
+# How do I find the rol version?
+#
+describe 'Rol.Version' do
+  it 'returns the rol() version' do
+    Rol::Version.must_equal '0.0.1'
+  end
+end
+
+
+#
+# What arguments does rol take and what restrictions do they have?
+#
+describe 'arguments' do
+  it 'expects one argument that behaves like a hash' do
+    rol({ x: 42 })
+  end
+  it 'raises an exception when the argument does not respond to #each_pair' do
+    exception = proc { rol([1,2,3]) }.must_raise ArgumentError
+    exception.message.must_equal "rol(hash): 'hash' argument must respond to #each_pair"
+  end
+  it 'raises an exception when called with more than one argument' do
+    exception = proc { rol({}, 42) }.must_raise ArgumentError
+    exception.message.must_equal 'wrong number of arguments (2 for 0..1)'
+  end
+  it 'does not raise an exception when called with no arguments' do
+    rol()
+  end
+end
+
+
+#
+# What does rol return?
+#
+describe 'return value' do
+  it 'returns an instance of Object' do
+    rol().class.must_equal Object
+  end
+  it 'returns an instance of Object with no additional methods when no arguments are supplied' do
+    rol().methods.must_equal Object.new.methods
+  end
+  it 'returns an instance of Object with no additional methods when an empty hash is supplied' do
+    rol({}).methods.must_equal Object.new.methods
+  end
+end
+
+
+#
+# What happens when I define an attribute?
+#
+describe 'defining an attribute' do
+  before do
+    @object = rol({ x: 42 })
+  end
+  it 'creates the attribute' do
+    @object.instance_variables.must_include :@x
+  end
+  it 'creates a get method for the attribute' do
+    @object.methods.must_include :x
+  end
+  it 'creates a set method for the attribute' do
+    @object.methods.must_include :x=
+  end
+  it 'sets the initial value of the attribute' do
+    @object.instance_variable_get(:@x).must_equal 42
+  end
+end
+
+
+#
+# What does the get method for an attribute do?
+#
+describe 'attribute get method' do
+  it 'returns the value of the attibute' do
+    @object = rol({ x: 42 })
+    @object.x.must_equal 42
+  end
+end
+
+
+#
+# What does the set method for an attribute do?
+#
+describe 'attribute set method' do
+  it 'sets the value of the attribute' do
+    @object = rol({ x: 42 })
+    @object.x = 24
+    @object.instance_variable_get(:@x).must_equal 24
+  end
+end
+
+
+#
+# What are the restrictions on attribute names?
+#
+describe 'attribute names' do
+  it 'allows capitalized attribute names' do
+    rol({ Capitalized: 42 }).methods.must_include :Capitalized
+  end
+  it 'raises an exception if the attribute name ends with =' do
+    exception = proc { rol({ 'name=' => 42 }) }.must_raise ArgumentError
+    exception.message.must_equal "rol(hash): attribute name 'name=' must not end with ="
+  end
+end
+
+
+#
+# Can I define more than one attribute?
+#
+describe 'multiple attribute definitions' do
+  it 'allows many attributes to be defined' do
+    object = rol({ first: 1, second: 2, third: 3 })
+    object.methods.must_include :first
+    object.methods.must_include :second
+    object.methods.must_include :third
+  end
+end
+
+
+#
+# What happens when I define a method?
+#
+describe 'method definition' do
+  before do
+    @object = rol({ my_method: -> (x) { x * 2 } })
+  end
+  it 'allows a method to be defined' do
+    @object.methods.must_include :my_method
+  end
+  it 'defines the method as read-only' do
+    @object.methods.wont_include :my_method=
+  end
+  it 'defines a method that can actually be called' do
+    @object.my_method(3).must_equal 6
+  end
+end
+
+
+#
+# What are the restrictions on method names?
+#
+describe 'method names' do
+  it 'does not raise an exception if the method name ends with =' do
+    rol({ 'name=' => -> {} })
+  end
+end
+
+
+#
+# Can methods access attributes?
+#
+describe 'method invocation' do
+  it 'invokes the method in the context of the object' do
+    object = rol({
+      height: 2,
+      width: 3,
+      area: -> { @height * @width }   # @height and @width must be accessible
+    })
+    object.area.must_equal 6
+  end
+end
+
+
+#
+# Provide Kernel.rol() as an alias for Rol.rol():
+#
+#   o = Rol.rol({ x: 42 })
+#   o = rol({ x: 42 })      # easier to read, faster to write
+#   o = %o{ x: 42 }         # would be nicer still
+#
+describe 'Kernel.rol()' do
+  it 'is defined' do
+    Kernel.methods.must_include :rol
+  end
+  it 'invokes Rol.rol()' do
+    Rol.expects(:rol)
+    rol()
+  end
+  it 'blindly forwards any and all arguments it was called with along to Rol.rol()' do
+    Rol.expects(:rol).with('hello', 'doctor', 'name', 'continue', 'yesterday', 'tomorrow')
+    rol('hello', 'doctor', 'name', 'continue', 'yesterday', 'tomorrow')
+  end
+  it 'passes nothing to Rol.rol() when called with no arguments' do
+    Rol.expects(:rol).with()
+    rol()
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: rol
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Michael Lewandowski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+description: |2
+                                    rol defines Ruby objects from a hash of attributes and methods
+email: milewdev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/rol.rb
+- lib/rol/kernel.rb
+- lib/rol/version.rb
+- test/rol/rol_test.rb
+homepage: https://github.com/milewdev/rol
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- Ruby 2
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: rol defines Ruby objects from a hash of attributes and methods
+test_files:
+- test/rol/rol_test.rb