kindah 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YzkwOGY0YWQ3YTZiYjA0Yzc3MmY0NjY0MTNlMmZjOWYzMTI5MjNlYw==
+  data.tar.gz: !binary |-
+    Zjk3MTgyZDFlMGFkNTliMzRhY2Q0MWEwYzY5YTlmZjUyM2MzZTYwMQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MTZlZmI1OGZlNWQ1NjU2NmY3MzJkYzM2MmY0NDQ1MWIzMDI0NmQ0NzQ1NzE2
+    Nzc0MDBjZTY4MTQyYmU1ZTg2ZDU3OGYzNDUyZTAzNDlmNzc2NzA0MTQ5Y2Fi
+    MDM0MWMwNzBmOTY2MWVjOTEzOGM1ZjEzYTE3ZDhmMTkyYWQwYWQ=
+  data.tar.gz: !binary |-
+    YzI1M2FkZTUyOWVhMjVlOWE3MzlmZDAwZDYxY2RjZTk4YTY0OGJiZDM4YjE4
+    YTE5YTZhZTNiYzAwZGJjYWZlNTZhY2IzY2E2NjEwZDE5NzNjZjVjOGRmNWIy
+    MjdhMWE2ZmVlNmNiYzM1ZmFiZDM4ODlmZjU5ZjU1Y2UzYmQ3MGY=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-gemset

@@ -0,0 +1 @@
+kindah

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3-p429

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-19mode
+env:
+  - COVERALLS=true

data/Gemfile

@@ -0,0 +1,5 @@
+source 'http://rubygems.org'
+
+gem 'crystalline'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Joe Fredette
+
+MIT License
+
+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/README.md

@@ -0,0 +1,228 @@
+# kindah [![Gem Version](https://badge.fury.io/rb/kindah.png)](http://badge.fury.io/rb/kindah)[![Build Status](https://travis-ci.org/jfredett/kindah.png?branch=master)](http://travis-ci.org/jfredett/kindah)[![Code Climate](https://codeclimate.com/github/jfredett/kindah.png)](https://codeclimate.com/github/jfredett/kindah)[![Coverage Status](https://coveralls.io/repos/jfredett/kindah/badge.png?branch=master)](https://coveralls.io/r/jfredett/kindah)
+
+Kindah is an implementation of Parameterized Classes for Ruby.
+
+Kindah is unreleased, pre-alpha software, use at your own risk.
+
+Most of this README should work, but it's not yet well-tested, so be careful.
+
+## Description
+
+A parameterized class is a 'higher order' class, it's similar to (but definitely
+not equivalent or as powerful as) a dependently-typed class. If you're familiar
+with type theory (and particularly with haskell), it's analogous to a 'kind',
+but one rank lower. So whereas a rank-2 type is the 'type of types' and is built
+of types and other 'kinds' (ie, rank-1 and rank-2 types), these parameterized
+classes occupy some of the same space as dependent types (ie, rank-1 types which
+are parameterized by rank-0 types (that is, values)).
+
+This library is not a rigorous implementation of any type system, it's merely
+inspired by the concept, and built for a very specific purpose. The static
+injection pattern.
+
+### Static Injection
+
+Static injection is a type of dependency injection which happens once, generally
+at compile-time, or at interpretation/loading time for interpeted languages.
+Compared with setter/constructor injection, this is more akin to setter
+injection, but where the setter is promoted to the class itself. This is useful
+particularly where you need multiple versions of the same class which have
+different 'engines' which drive them. A motivating example is an Indexing
+interface for a database. Consider
+
+
+    class Index
+      attr_reader :indexing_engine
+
+      def initialize(indexing_engine = DefaultIndexingEnging)
+        @indexing_engine = indexing_engine.new
+      end
+
+      def insert(data)
+        indexing_engine.insert(data)
+      end
+
+      #snip
+    end
+
+    #later
+
+    Index.new(BTree)
+
+Here, we use constructor injection to manage which indexing engine to use,
+however, this leaks the abstraction to an inappropriate place, it should never
+be possible to change the engine after it's been chosen the first time. In
+particular it expresses the wrong relationship. An index does not _have a_
+engine, an index, in some sense, _is it's_ engine. That is, a BTree Index _is_
+a BTree, with some pleasant interface adhered to it. Similarly, a Hash Index
+_is_ fundamentally a hashtable, with the _same pleasant interface_.
+
+One method for accomplishing this type of abstraction in ruby is via modules,
+but Modules ought to expose cross-cutting functionality and ought to bear no
+statefullness of their own, and in the case of Index, there is a fair amount of
+desire to include some statefulness. Further, an aesthetic desire exists to
+invert this relationship to better express the dominant status of the _Index_
+over it's _Engine_. The solution that Kindah offers looks something like this:
+
+     parameterized_class :Index do |engine|
+       def indexing_engine
+         @engine ||= engine.new
+       end
+
+       def insert(data)
+         indexing_engine.insert(data)
+       end
+
+       #snip
+     end
+
+     #later
+
+     Index(BTree).new
+
+So, looking at that last line, you're probably thinking, "Okay, so what? You
+moved the BTree bit to the left." Yes. Precisely, I've also imposed a set of
+restrictions and implemented some pleasant features for talking about
+`Index(BTree)` as a type in it's own right. For instance,
+`Index(BTree).new.is_a? Index` will return `true`, but `Index(BTree).new.is_a?
+Index(HashTable)` will return `false`. Similarly, depending on defaults provided
+to the above block, `Index` will be an instantiable class. 
+
+
+### Other uses
+
+In this way you can hopefully see how to use this to manage some basic
+dependency injection problems, however, Kindah lends itself to other uses, one
+of the chief uses is metaprogramming based on values (rather than classes).
+
+Consider the implementation of a classic Dependent Type, the finite vector.
+
+A Vector is a list of length `n` with `O(1)` access to any element of the list
+for read or write, and at most `O(n)` memory use. A simple implementation in
+ruby is to metaprogram `n` 'slots' into a class, and wrap them in an interface
+so that the usual `#[]` and `#[]=` operations work as expected, with bounds
+checking and the like.
+
+An implementation follows using pure ruby and using Kindah.
+
+    #pure ruby
+    class Vector
+      attr_reader :order
+
+      def initialize(order)
+        @order = order
+      end
+
+      def [](slot)
+        bounds_check! slot
+        instance_variable_get("@slot_#{slot}")
+      end
+
+      def []=(slot, value)
+        bounds_check! slot
+        instance_variable_set("@slot_#{slot}", value)
+      end
+
+      private
+
+      def bounds_check!(value)
+        0 <= value && value < order
+      end
+    end
+
+    #usage
+
+    v = Vector.new(2)
+    v[0] = :test_value
+    v[1] = :please_ignore
+
+    v[0] #=> :test_value
+
+    #with kindah
+
+    parameterized_class :Vector do |size|
+      def order
+        size
+      end
+
+      def [](slot)
+        bounds_check! slot
+        instance_variable_get("@slot_#{slot}")
+      end
+
+      def []=(slot, value)
+        bounds_check! slot
+        instance_variable_set("@slot_#{slot}", value)
+      end
+
+      private
+
+      def bounds_check!(value)
+        0 <= value && value < order
+      end
+    end
+
+    v = Vector(2).new
+    v[0] = :test_value
+    v[1] = :please_ignore
+
+    v[0] #=> :test_value
+
+So... what's the difference? It's basically the same, arguably the latter is
+more complicated.
+
+Well, there are a couple advantages beyond the aesthetic API the latter
+provides. First, in the former, we have to allocate some extra storage for the
+order, whereas in the latter it's hardcoded (via metaprogramming) into the class
+proper. Second, imagine an implementation of dot-product, which requires the two
+vectors to be of the same length. In the former, we must examine orders
+directly, eg:
+
+    class Vector
+      def dot(other)
+        raise unless order == other.order
+        #impl
+      end
+    end
+
+In the latter case, we can check the class, which is only the same if the two
+instances were created via the same `Vector(n)` function, eg:
+
+    parameterized_class :Vector do |order|
+      def dot(other)
+        raise unless other.is_a?(self.class)
+        #impl
+      end
+    end
+
+This becomes more valuable when you have a few of these parameters to throw
+around, for instance, imagine a `n x m` matrix class. In pure ruby, if you want
+to add two instances together, you must first ensure that it matches both width
+and height, with a kindah-based parameterized class, you can simply compare that
+the classes are the same. Essentially, it's poor man's type checking.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'kindah'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kindah
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/gem_tasks"
+
+require 'crystalline/rake'

data/kindah.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kindah/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "kindah"
+  spec.version       = Kindah::VERSION
+  spec.authors       = ["Joe Fredette"]
+  spec.email         = ["jfredett@gmail.com"]
+  spec.description   = %q{Kindah is an implementation of Parameterized Classes for Ruby.}
+  spec.summary       = %q{Kindah is an implementation of Parameterized Classes for Ruby.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "katuv"
+end

data/lib/kindah/ast/class_methods.rb

@@ -0,0 +1,11 @@
+module Kindah
+  class ClassMethods
+    include Katuv::Node
+
+    terminal!
+
+    def self.name
+      'class_methods'
+    end
+  end
+end

data/lib/kindah/ast/class_template.rb

@@ -0,0 +1,8 @@
+module Kindah
+  class ClassTemplate
+    include Katuv::Node
+
+    terminal ClassMethods
+    terminal InstanceMethods
+  end
+end

data/lib/kindah/ast/instance_methods.rb

@@ -0,0 +1,11 @@
+module Kindah
+  class InstanceMethods
+    include Katuv::Node
+
+    terminal!
+
+    def self.name
+      'instance_methods'
+    end
+  end
+end

data/lib/kindah/ast.rb

@@ -0,0 +1,4 @@
+require 'kindah/ast/instance_methods'
+require 'kindah/ast/class_methods'
+
+require 'kindah/ast/class_template'

data/lib/kindah/cache.rb

@@ -0,0 +1,15 @@
+module Kindah
+  class Cache
+    def self.[](*args)
+      storage[args]
+    end
+
+    def self.[]=(*args, last)
+      storage[args] = last
+    end
+
+    def self.storage
+      @storage ||= {}
+    end
+  end
+end

data/lib/kindah/compiler.rb

@@ -0,0 +1,54 @@
+module Kindah
+  class Compiler
+    extend Forwardable
+
+    def initialize(ast)
+      @ast = ast
+    end
+
+    def class_methods
+      safe_fetch ClassMethods
+    end
+
+    def instance_methods
+      safe_fetch InstanceMethods
+    end
+
+    delegate [:arity, :block, :children] => :@ast
+    def class_name
+      @ast.name
+    end
+
+    def each_parameter
+      class_methods.parameters.each.with_index do |(_, name), idx|
+        yield name, idx if block_given?
+      end
+    end
+
+    def compile!(location = Object)
+      compiler = self
+
+      location.send(:define_method, compiler.class_name) do |*args|
+        Kindah::Cache[compiler.class_name, *args] ||= Class.new do
+          compiler.each_parameter do |name, idx|
+            define_singleton_method(name) { args[idx] }
+            define_method(name) { self.class.send(name) }
+          end
+
+          #because ruby is weird...
+          instance_eval &compiler.class_methods
+          class_eval &compiler.instance_methods
+        end
+      end
+
+      nil
+    end
+
+    private
+
+    def safe_fetch(klass)
+      return proc {} unless children.has_key?(klass)
+      children[klass].block
+    end
+  end
+end

data/lib/kindah/version.rb

@@ -0,0 +1,3 @@
+module Kindah
+  VERSION = "0.0.1"
+end

data/lib/kindah.rb

@@ -0,0 +1,23 @@
+require "kindah/version"
+
+require 'katuv'
+require 'forwardable'
+require 'singleton'
+
+require 'kindah/ast'
+require 'kindah/cache'
+require 'kindah/compiler'
+
+module Kindah
+  def self.class_template(name, opts={}, &block)
+    Kindah::ClassTemplate.new(name, opts.merge(parent: nil), &block)
+  end
+
+  def self.class_template!(name, opts={}, &block)
+    compile! class_template(name, opts, &block)
+  end
+
+  def self.compile!(template)
+    Kindah::Compiler.new(template).compile!
+  end
+end

data/spec/integration/parameterized_class_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Kindah do
+  before :all do
+    Kindah.class_template! :Test do
+      class_methods do |bar|
+        def foo_class
+          bar + 1
+        end
+      end
+
+      instance_methods do
+        def foo_instance
+          bar + 1
+        end
+
+        def initialize
+          @ivar = 1
+        end
+
+        attr_reader :ivar
+      end
+    end
+  end
+
+  subject(:test_instance) { Test(1).new }
+
+  it { should respond_to :bar }
+  it { should respond_to :foo_instance }
+  it { should respond_to :ivar }
+
+  its(:ivar) { should == 1 }
+
+  its(:class) { should respond_to :bar }
+  its(:class) { should respond_to :foo_class }
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'crystalline/spec'
+
+#include helpers
+Dir["./spec/helpers/*.rb"].each { |file| require file }
+
+#include shared examples
+Dir["./spec/shared/*_examples.rb"].each { |file| require file }
+
+Coveralls.wear! if ENV['COVERALLS']
+
+Crystalline::Spec.install!
+
+require 'kindah'

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: kindah
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Joe Fredette
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: katuv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Kindah is an implementation of Parameterized Classes for Ruby.
+email:
+- jfredett@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-gemset
+- .ruby-version
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- kindah.gemspec
+- lib/kindah.rb
+- lib/kindah/ast.rb
+- lib/kindah/ast/class_methods.rb
+- lib/kindah/ast/class_template.rb
+- lib/kindah/ast/instance_methods.rb
+- lib/kindah/cache.rb
+- lib/kindah/compiler.rb
+- lib/kindah/version.rb
+- spec/integration/parameterized_class_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: Kindah is an implementation of Parameterized Classes for Ruby.
+test_files:
+- spec/integration/parameterized_class_spec.rb
+- spec/spec_helper.rb