mozart 0.0.1 → 0.0.2

data/example.rb

@@ -0,0 +1,48 @@
+require_relative "lib/mozart"
+
+class BasicCalculator
+  include Mozart::Environment
+
+  def initialize
+    array = []
+
+    features << X(:push, array)
+
+    _(:data, X(:reduce, :clear, array))
+  end
+
+  def sum
+    _(:data).reduce(0, :+).tap { _(:data).clear }
+  end
+end
+
+stack = BasicCalculator.new
+stack.push(10)
+stack.push(20)
+stack.push(30)
+
+p stack.sum
+
+stack.push(20)
+stack.push(50)
+
+p stack.sum
+
+
+class Person
+  include Mozart::Composable
+
+  def initialize(params)
+    features << V(:name, :email, params) 
+  end
+
+  def to_s
+    "#{name} <#{email}>"
+  end
+end
+
+
+person = Person.new(:name  => "Gregory Brown",
+                    :email => "gregory.t.brown@gmail.com")
+
+puts person

data/lib/mozart.rb

@@ -1,5 +1,7 @@
-require "mozart/version"
-
-module Mozart
-  # Your code goes here...
-end
+require_relative "mozart/version"
+require_relative "mozart/composite"
+require_relative "mozart/composable"
+require_relative "mozart/value"
+require_relative "mozart/context"
+require_relative "mozart/single_assignment"
+require_relative "mozart/environment"

data/lib/mozart/composable.rb

@@ -0,0 +1,29 @@
+require_relative "composite"
+
+module Mozart
+  module Composable
+    private
+
+    def X(*method_names, target)
+      Mozart.context(*method_names).new(target)
+    end
+
+    def V(*field_names, params)
+      Mozart.value(*field_names).new(params)
+    end
+
+    def features
+      @features ||= Mozart::Composite.new
+    end
+
+    def respond_to_missing?(m, *a, &b)
+      features.receives?(m)
+    end
+
+    def method_missing(m, *a, &b)
+      return super unless features.receives?(m)
+
+      features.dispatch(m, *a, &b)
+    end
+  end
+end

data/lib/mozart/composite.rb

@@ -0,0 +1,39 @@
+module Mozart
+  AmbiguousMessageError = Class.new(StandardError)
+
+  class Composite
+    def initialize
+      self.parts = []
+    end
+
+    def <<(part)
+      parts << part
+    end
+
+    def receives?(message)
+      !!recipient(message)
+    end
+
+    def dispatch(message, *a, &b)
+      target = recipient(message)
+      
+      unless target
+        raise NotImplementedError, "No recipient implements #{message}" 
+      end
+
+      target.public_send(message, *a, &b)
+    end
+
+    private
+
+    def recipient(message)
+      target, *rest = parts.select { |part| part.respond_to?(message) }
+
+      raise AmbiguousMessageError unless rest.empty?
+
+      target
+    end
+
+    attr_accessor :parts
+  end
+end

data/lib/mozart/context.rb

@@ -0,0 +1,23 @@
+module Mozart
+  def self.context(*accepted_methods, &class_definition)
+    Class.new do
+      def initialize(target)
+        self.target = target
+      end
+
+      define_method :respond_to_missing? do |m, *a|
+        accepted_methods.include?(m)
+      end
+
+      def method_missing(m, *a, &b)
+        raise NotImplementedError unless respond_to_missing?(m)
+
+        target.public_send(m, *a, &b)      
+      end
+
+      private 
+
+      attr_accessor :target
+    end
+  end
+end

data/lib/mozart/environment.rb

@@ -0,0 +1,6 @@
+module Mozart
+  module Environment
+    include SingleAssignment
+    include Composable
+  end
+end

data/lib/mozart/single_assignment.rb

@@ -0,0 +1,20 @@
+module Mozart
+  module SingleAssignment
+    def _(*args)
+      @__internals__ ||= {}
+
+      case args.count
+      when 1
+        @__internals__[args.first]
+      when 2
+        if @__internals__.key?(args.first)
+          raise "Single assignment only!"
+        else
+          @__internals__[args.first] = args.last
+        end
+      else
+        raise ArgumentError
+      end
+    end
+  end
+end

data/lib/mozart/value.rb

@@ -0,0 +1,33 @@
+module Mozart
+  def self.value(*field_names, &block)
+    Class.new do
+      define_method(:initialize) do |params={}|
+        raise ArgumentError unless params.keys == field_names
+
+        self.__data__ = {}
+
+        params.each { |k,v| __data__[k] = v }
+
+        __data__
+      end
+
+      def ==(other)
+        self.class == other.class && __data__ == other.__data__
+      end
+
+      alias_method :eql?, :==
+
+      def hash
+        __data__.hash
+      end
+
+      field_names.each do |name|
+        define_method(name) { __data__[name] }
+      end
+
+      protected
+
+      attr_accessor :__data__
+    end
+  end
+end

data/lib/mozart/version.rb

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

data/mozart.gemspec

@@ -4,8 +4,8 @@ require File.expand_path('../lib/mozart/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ["Gregory Brown"]
   gem.email         = ["gregory.t.brown@gmail.com"]
-  gem.description   = %q{An experimental tool implementing mixins via composition}
-  gem.summary       = %q{An experimental tool implementing mixins via composition}
+  gem.description   = %q{Tools for making object composition easier}
+  gem.summary       = %q{Tools for making object composition easier}
   gem.homepage      = "https://github.com/elm-city-craftworks/mozart"
 
   gem.files         = `git ls-files`.split($\)

data/test/composite_test.rb

@@ -0,0 +1,47 @@
+require "minitest/autorun"
+
+require_relative "../lib/mozart/composite"
+require_relative "../lib/mozart/value"
+
+describe Mozart::Composite do
+  let(:composite) { Mozart::Composite.new }
+
+  let(:parts) do
+    [ Mozart.value(:foo).new(:foo => :returned_by_foo),
+      Mozart.value(:bar).new(:bar => :returned_by_bar) ]
+  end
+
+  it "knows what messages it can receive" do
+    parts.each { |part| composite << part }
+
+    assert composite.receives?(:foo), "Expected composite to receive foo"
+    assert composite.receives?(:bar), "Expected composite to receive bar"
+    refute composite.receives?(:baz), "Did not expect composite to receive baz"
+  end
+
+  it "dispatches messages to its parts" do
+    parts.each { |part| composite << part }
+
+    composite.dispatch(:foo).must_equal(:returned_by_foo)
+    composite.dispatch(:bar).must_equal(:returned_by_bar)
+  end
+
+  it "raises an exception for unhandled messages" do
+    assert_raises(NotImplementedError) do
+      composite.dispatch(:baz)
+    end
+  end
+  
+  it "raises an exception for messages with multiple recipients" do
+    composite << Mozart.value(:foo).new(:foo => true)
+    composite << Mozart.value(:foo).new(:foo => false)
+
+    assert_raises(Mozart::AmbiguousMessageError) do
+      composite.dispatch(:foo) 
+    end
+
+    assert_raises(Mozart::AmbiguousMessageError) do
+      composite.receives?(:foo)
+    end
+  end
+end

data/test/context_test.rb

@@ -0,0 +1,20 @@
+require "minitest/autorun"
+require_relative "../lib/mozart/context"
+
+describe "Mozart.context" do
+
+  it "must restrict method calls" do
+    stack_builder = Mozart.context(:push, :pop)
+    stack = stack_builder.new([])
+
+    stack.push(2)
+    stack.push(3)
+
+    stack.pop.must_equal 3
+    stack.pop.must_equal 2
+
+    assert_raises(NotImplementedError) do
+      stack[0]
+    end
+  end
+end

data/test/suite.rb

@@ -0,0 +1,2 @@
+require_relative "composite_test"
+require_relative "value_test"

data/test/value_test.rb

@@ -0,0 +1,39 @@
+require "minitest/autorun"
+require_relative "../lib/mozart/value"
+
+describe "Mozart.value" do
+  it "produces Struct-like classes" do
+    pos_builder = Mozart.value(:x, :y)
+
+    pos1 = pos_builder.new(:x => 10, :y => 20)
+    pos1.x.must_equal(10)
+    pos1.y.must_equal(20)
+  end
+
+  it "implements equality" do
+    pos_builder = Mozart.value(:x, :y)
+
+    pos1 = pos_builder.new(:x => 10, :y => 15)
+    pos2 = pos_builder.new(:x => pos1.x,     :y => pos1.y)
+    pos3 = pos_builder.new(:x => pos1.x + 1, :y => pos1.y)
+
+    pos1.must_equal(pos2)
+
+    pos1.wont_equal(pos3)
+    pos2.wont_equal(pos3)
+  end
+
+  it "implements hash" do
+    pos_builder = Mozart.value(:x, :y)
+
+    pos1 = pos_builder.new(:x => 10,         :y => 15)
+    pos2 = pos_builder.new(:x => pos1.x,     :y => pos1.y)
+    pos3 = pos_builder.new(:x => pos1.x + 1, :y => pos1.y)
+
+    data = { pos1 => true }
+
+    assert data[pos1]
+    assert data[pos2]
+    refute data[pos3]
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mozart
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,9 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-05 00:00:00.000000000 Z
+date: 2012-07-06 00:00:00.000000000 Z
 dependencies: []
-description: An experimental tool implementing mixins via composition
+description: Tools for making object composition easier
 email:
 - gregory.t.brown@gmail.com
 executables: []
@@ -22,10 +22,20 @@ files:
 - Gemfile
 - LICENSE
 - README.md
-- Rakefile
+- example.rb
 - lib/mozart.rb
+- lib/mozart/composable.rb
+- lib/mozart/composite.rb
+- lib/mozart/context.rb
+- lib/mozart/environment.rb
+- lib/mozart/single_assignment.rb
+- lib/mozart/value.rb
 - lib/mozart/version.rb
 - mozart.gemspec
+- test/composite_test.rb
+- test/context_test.rb
+- test/suite.rb
+- test/value_test.rb
 homepage: https://github.com/elm-city-craftworks/mozart
 licenses: []
 post_install_message: 
@@ -49,5 +59,9 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: An experimental tool implementing mixins via composition
-test_files: []
+summary: Tools for making object composition easier
+test_files:
+- test/composite_test.rb
+- test/context_test.rb
+- test/suite.rb
+- test/value_test.rb

data/Rakefile

@@ -1,2 +0,0 @@
-#!/usr/bin/env rake
-require "bundler/gem_tasks"