lumberjack-dsl 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--colour

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gem "rspec"

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2007-2008 Ryan Allen, FlashDen Pty Ltd
+
+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.markdown

@@ -0,0 +1,57 @@
+Lumberjack is best summed up as a generic DSL for constructing object trees.
+
+It works great for configuration files, for generating a tree of configuration
+objects for later reflection or what-not. But in reality you could use it for
+whatever you're willing to dream up.
+
+I apologise for the lack of documentation :) Below is a code example to get you
+started, any questions, shoot me a message!
+
+Now, that code example:
+
+    require 'lumberjack'
+
+    class Person
+      
+      attr_accessor :age, :gripes, :chums
+      
+      def initialize(name)
+        @name = name
+        @gripes = []
+        @chums = []
+      end
+    end
+
+    class Gripe
+      def initialize(desc)
+        @desc = desc
+      end
+    end
+
+    tree = Lumberjack.construct do
+      
+      # we're in list / instanciate object scope
+      
+      @john = person 'John (is a doondy head)' do
+        # we instanticated an object, so now we're in attr assignment scope
+        age 12 # this is equiv to @john.age = 12
+        gripes do # open up a colection on john...
+          # now we're back in list / instanticate object scope
+          gripe 'untested code' # creating a gripe
+          gripe 'no beer' # and another
+        end # out of gripes, back to john attr assignment
+      end # out of john
+      
+      # we're back to creating people:
+      
+      person 'Ryan' do
+        age 25 
+      end
+      
+      person 'Tim' do
+        age 'Infinite'
+        chums @john # instance vars are shared across Lumberjack.construct
+      end
+    end
+
+    puts tree.inspect

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |s|
+	s.pattern = '*_spec.rb'
+end
+
+task :default => :spec

data/examples/people.rb

@@ -0,0 +1,5 @@
+person 'John S', 50
+person 'Andrea', 46
+person 'John R', 26
+person 'Sarah', 24
+person 'Ethan', 10

data/lumberjack.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+  s.name        = "lumberjack-dsl"
+  s.version     = "0.0.1"
+  s.authors     = ["Ryan Allen", "Steve Hodgkiss", "John Barton", "James Dowling"]
+  s.email       = ["ryan@yeahnah.org", "steve@hodgkiss.me", "jrbarton@gmail.com", "jamesd741@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Lumberjack is best summed up as a generic DSL for constructing object trees.}
+  s.description = %q{}
+
+  s.rubyforge_project = "lumberjack-dsl"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["."]
+
+  s.add_development_dependency "rspec"
+end

data/lumberjack.rb

@@ -0,0 +1,153 @@
+class Lumberjack
+
+  def self.construct(initial_scope = [], &block)
+    builder = new(initial_scope)
+    builder.__process(block)
+  end
+
+  @@methods_to_keep = /^__/, /class/, /instance_eval/, /method_missing/,
+    /instance_variable_(g|s)et/, /instance_variables/, /inspect/, /send/,
+    /^object_id/, /^respond_to/
+
+  instance_methods.each do |m|
+    undef_method m unless @@methods_to_keep.find { |r| r.match m }
+  end
+
+  def initialize(initial_scope)
+    @initial_scope = initial_scope
+    @scope_stack ||= []
+  end
+
+  def __process(block)
+    @scope = [@initial_scope]
+    instance_eval(&block) if block
+    tree
+  rescue
+    raise $!
+  end
+
+  # syntatic sugar for scope resolution
+  def /(ignore_me)
+    self
+  end
+
+  def load_tree_file(filename)
+    File.open filename, 'r' do |f|
+      eval f.read, binding, __FILE__, __LINE__
+    end
+  end
+
+  def shared_branch(branch_name, &block)
+    instance_variable_set "@#{branch_name}", lambda(&block)
+  end
+
+  def graft_branch(branch_name)
+    branch = instance_variable_get("@#{branch_name}")
+    raise "Attemption to graft branch #{branch_name} which is undefined" unless branch
+    instance_eval(&branch)
+  end
+
+  def prune(method, value)
+    current_scope.delete_if do |twig|
+      twig.respond_to?(method) && twig.send(method) == value
+    end
+  end
+
+  def method_missing(*args, &block)
+    if still_modifying_scope?(args, block)
+      @scope_stack << args.first
+    else
+      assign_to_current_scope(args, block)
+    end
+    self
+  end
+
+  private
+
+  def assign_to_current_scope(args, block)
+    if current_scope.respond_to?(:<<)
+      assign_to_array_with(args, block)
+    else
+      assign_to_instance_with(args, block)
+    end
+  end
+
+  def assign_to_instance_with(args, block)
+    accessor = args.shift
+    if accessor.to_s[-1].chr == '!'
+      # create class based on the accessor name
+      assign_subvalues_to_instance(accessor, args, block)
+    elsif block and args.empty?
+      # accessor is to refer to an array
+      current_array_instance = get_accessor_value(accessor)
+      evaluate_block_within_context(current_array_instance, block)
+    elsif args.length == 1
+      # splat to avoid array and directly assign the argument
+      current_scope.send("#{accessor}=", *args)
+    else
+      # assign array
+      current_scope.send("#{accessor}=", args)
+    end
+  end
+
+  def assign_to_array_with(args, block)
+    klass = args.shift
+    instance = build_class(klass, args)
+    current_scope << instance # add this instance to the scoped Array
+    evaluate_block_within_context(instance, block) if block
+  end
+
+  def assign_subvalues_to_instance(accessor, args, block)
+    accessor_class = accessor.to_s[0...-1]
+    instance = build_class(accessor_class, args)
+    instance.parent = current_scope if instance.respond_to?(:parent=)
+    current_scope.send("#{accessor_class}=", instance)
+    evaluate_block_within_context(instance, block) if block
+  end
+
+  def build_class(klass, args)
+    @scope_stack << klass
+    scoped_class = @scope_stack.join('/')
+    @scope_stack = []
+    classify(scoped_class).new(*args)
+  end
+
+  def evaluate_block_within_context(accessor, block)
+    @scope.push accessor
+    instance_eval(&block)
+    @scope.pop
+  end
+
+  def get_accessor_value(accessor)
+    if current_scope.send("#{accessor}").nil?
+      current_scope.send("#{accessor}=", [])
+    end
+    current_scope.send("#{accessor}")
+  end
+
+  def still_modifying_scope?(args, block)
+    # if we only have one arg, and no block, then we're trying to build a
+    # module scope, i.e. a/b/c/d would resolve to A::B::C::D,
+    args.length == 1 && block.nil?
+  end
+
+  def current_scope
+    @scope.last
+  end
+
+  def tree
+    @scope.first
+  end
+
+  # Turns an underscored path into the class it represents
+  #
+  # Usage: classify("some/cool_klass") => Some::CoolKlass
+  def classify(class_name)
+    klass = class_name.split('/').collect do |component|
+      camels = component.split('_')
+      camels.collect { |c| c.capitalize }.join
+    end.join('::')
+    eval("::#{klass}")
+  end
+
+end

data/lumberjack_spec.rb

@@ -0,0 +1,311 @@
+require 'bundler'
+Bundler.require
+$: << '.'
+require 'lumberjack'
+
+class Family
+  attr_accessor :name, :members, :heritage
+  def initialize(name = nil, args = {})
+    @name = name
+    args.each { |k,v| send "#{k}=", v }
+  end
+end
+
+class Person
+  attr_accessor :given_name, :age
+  def initialize(name = nil, age = nil)
+    @given_name, @age = name, age
+  end
+end
+
+class Showroom < Array
+end
+
+class Vehicle
+  class Heavy < Vehicle
+    class ReallyHeavy < Heavy
+    end
+  end
+  attr_accessor :name, :wheels, :person
+  def initialize(args = {:name => 'A Car, ya mum'})
+    @name = args[:name]
+    @wheels = SetOfWheels.new
+  end
+end
+
+class SetOfWheels < Array
+end
+
+class Wheel
+  attr_accessor :wear
+  def initialize(args)
+    @wear = args[:wear]
+  end
+end
+
+describe Lumberjack do
+
+  it 'construct returns an empty list' do
+    Lumberjack.construct.should be_empty
+  end
+  
+  it 'testcan create a single class' do
+    tree = Lumberjack.construct do
+      family {} # api change w/ scoping requires a block to be passed, otherwise can't tell if you're
+                # trying to resolve a nested scope
+    end
+    tree.length.should eq 1
+    tree.first.should be_instance_of Family
+  end
+  
+  it 'test can create a single class passing in args' do
+    tree = Lumberjack.construct do
+      family 'Allen', :heritage => :mixed
+    end
+    tree.length.should eq 1
+    tree.first.should be_instance_of Family
+    tree.first.name.should eq 'Allen'
+    tree.first.heritage.should eq :mixed
+  end
+  
+  it 'can create two classes passing in args' do
+    tree = Lumberjack.construct do
+      family 'Allen', :heritage => [:english, :irish]
+      family 'Ta\'eed', :heritage => [:iranian, :english]
+    end
+    tree.length.should eq 2
+    tree[0].should be_instance_of Family
+    tree[0].name.should eq 'Allen'
+    tree[0].heritage.should eq [:english, :irish]
+    tree[1].should be_instance_of Family
+    tree[1].name.should eq 'Ta\'eed'
+    tree[1].heritage.should eq [:iranian, :english]
+  end
+  
+  it 'can set instance members with block' do
+    tree = Lumberjack.construct do
+      family do
+        name 'Allen'
+        heritage [:english, :irish]
+      end
+    end
+    tree.length.should eq 1
+    tree[0].should be_instance_of Family
+    tree[0].name.should eq 'Allen'
+    tree[0].heritage.should eq [:english, :irish]
+  end
+  
+  it 'can used mixed constructor and instance members in_blocke' do
+    tree = Lumberjack.construct do
+      family 'Allen' do
+        heritage [:english, :irish]
+      end
+    end
+    tree.length.should eq 1
+    tree[0].should be_instance_of Family
+    tree[0].name.should eq 'Allen'
+    tree[0].heritage.should eq [:english, :irish]
+  end
+  
+  it 'create list in scoped instance if block with no args' do
+    tree = Lumberjack.construct do
+      family 'Allen' do
+        heritage [:english, :irish]
+        members do # working from here
+          person 'Tim', 58
+          person 'Jan', 54
+          person 'Ryan' do
+            age 24
+          end
+        end
+      end
+    end
+    tree.length.should eq 1
+    tree[0].should be_instance_of Family
+    tree[0].name.should eq 'Allen'
+    tree[0].heritage.should eq [:english, :irish]
+    tree[0].members.length.should eq 3
+    tree[0].members[0].given_name.should eq 'Tim'
+    tree[0].members[0].age.should eq 58
+    tree[0].members[1].given_name.should eq 'Jan'
+    tree[0].members[1].age.should eq 54
+    tree[0].members[2].given_name.should eq 'Ryan'
+    tree[0].members[2].age.should eq 24
+  end
+  
+  it 'can take generate arrays with comma semantics and tell the difference' do
+    tree = Lumberjack.construct do
+      family 'Allen' do
+        heritage :english, :irish
+      end
+    end
+    tree[0].heritage.should eq [:english, :irish]
+  end
+  
+  it 'will_push element onto object if list accessor is already initialized' do
+    vehicles = Lumberjack.construct do
+      vehicle :name => 'unicycle' do
+        wheels do
+          wheel :wear => 'bald'
+        end
+      end
+    end
+    vehicles[0].wheels.should be_instance_of SetOfWheels
+  end
+  
+  it 'can set initial context to something else besdies an array' do
+    showroom = Lumberjack.construct Showroom.new do
+      vehicle :name => 'a FERRARRI!!!1'
+      vehicle :name => 'a MASERATI!!!1'
+      vehicle :name => 'a PORCHE OMG!!!'
+    end
+    showroom.should be_instance_of Showroom
+    showroom.length.should eq 3
+  end
+  
+  # biggest hack ever, use a ! to isntanciate a class to an accessor, must be
+  # inferable by the accessor name, such a large hack, but we need it for
+  # production, and i'm sure other people will need it, so lets leave this 
+  # gaping flaw of lumberjack for the time being till we can think of something
+  # more nice and appropriate :/ :D
+  it 'can create instance of class via bang method' do 
+    cars = Lumberjack.construct do
+      vehicle :name => 'Prius (are owned by rich hippies)' do
+        person! 'Ryan' do # i so put my foot in here, i'm not a rich hippy!
+          age 25
+        end
+      end
+    end
+    eval('Vehicle').should eq Vehicle
+    cars[0].class.should eq Vehicle
+    cars[0].name.should eq 'Prius (are owned by rich hippies)'
+    cars[0].person.should be_instance_of Person
+    cars[0].person.age.should eq 25
+    cars[0].person.given_name.should eq 'Ryan'
+  end
+  
+  it 'can create list of primitives' do # not sure this is valid useage (of course it is you big dummy ryan from the past!)
+    tree = Lumberjack.construct do
+      array [:one, :two, :three]
+      array [:four, :five, :six]
+    end
+    tree.should eq [[:one, :two, :three], [:four, :five, :six]]
+  end
+
+  it 'we got backslashes that resolve scope or something' do
+    cars = Lumberjack.construct do
+      vehicle :name => 'Normal Car'
+      # unfortunatley we need to use parantehseshtheses here :(
+      vehicle/heavy(:name => 'Heavy Car')
+      vehicle/heavy/really_heavy(:name => 'Really Heavy Heavy Car')
+    end
+    cars[0].should be_instance_of Vehicle
+    cars[1].should be_instance_of Vehicle::Heavy
+    cars[2].should be_instance_of Vehicle::Heavy::ReallyHeavy
+  end
+  
+  it 'we can load in other files' do
+    family = Lumberjack.construct do
+      family 'Barton' do
+        heritage [:dutch, :mongrel_aussie]
+        members do
+          load_tree_file 'examples/people.rb'
+        end
+      end
+    end
+    
+    family.length.should eq 1
+    family.first.should be_instance_of Family
+    family.first.name.should eq 'Barton'
+    family.first.heritage.should eq [:dutch, :mongrel_aussie]
+
+    family.first.members.size.should eq 5
+
+    family.first.members.first.given_name.should eq 'John S'
+    family.first.members.first.age.should eq 50
+
+    family.first.members.last.given_name.should eq 'Ethan'
+    family.first.members.last.age.should eq 10
+  end
+  
+  it 'we can share branches that are defined' do
+    families = Lumberjack.construct do
+      
+      shared_branch :kids do
+        person 'Jack', 11
+        person 'Jill', 10
+      end
+      
+      family "Dad's new family" do
+        members do
+          person 'Dad', 45
+          graft_branch :kids
+        end
+      end
+      
+      family "Mum's new family" do
+        members do
+          person 'Mum', 40
+          person 'Red-headed step-child', 8
+          graft_branch :kids
+        end
+      end
+    end
+    
+    families.length.should eq 2
+    families[0].should be_instance_of Family
+    families[1].should be_instance_of Family
+    
+    families[0].members.size.should eq 3
+    families[0].members.any? {|m| m.given_name == 'Jack'}.should be_true
+    families[0].members.any? {|m| m.given_name == 'Jill'}.should be_true
+    
+    families[1].members.size.should eq 4
+    families[1].members.any? {|m| m.given_name == 'Jack'}.should be_true
+    families[1].members.any? {|m| m.given_name == 'Jill'}.should be_true
+  end
+
+  it 'we can remove twigs with prune' do
+    families = Lumberjack.construct do
+
+      shared_branch :kids do
+        person 'Jack', 12
+        person 'Jane', 10
+        person 'Bob', 10
+      end
+
+      shared_branch :update_kids do
+        prune :age, 10
+        person 'Will', 11
+      end
+
+      family "Dad's family" do
+        members do
+          person 'Dad', 45
+          person 'Mum', 49
+          prune :given_name, 'Mum'
+          person 'Mum', 26
+
+          graft_branch :kids
+          graft_branch :update_kids
+        end
+      end
+    end
+
+    families[0].members.any? {|m| m.given_name == 'Will' && m.age == 11}.should be_true
+    families[0].members.any? {|m| m.given_name == 'Jack' && m.age == 12}.should be_true
+    families[0].members.any? {|m| m.given_name == 'Mum' && m.age == 26}.should be_true
+    families[0].members.any? {|m| m.given_name == 'Dad' && m.age == 45}.should be_true
+  end
+  
+  it 'doesnt share branches that are undefined' do
+    # TODO: why does this output funny stuff
+    expect {
+      Lumberjack.construct do
+        family 'wont work' do
+          graft_branch :non_existant
+        end
+      end
+    }.to raise_error RuntimeError
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: lumberjack-dsl
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ryan Allen
+- Steve Hodgkiss
+- John Barton
+- James Dowling
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70259449806300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70259449806300
+description: ''
+email:
+- ryan@yeahnah.org
+- steve@hodgkiss.me
+- jrbarton@gmail.com
+- jamesd741@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- examples/people.rb
+- lumberjack.gemspec
+- lumberjack.rb
+- lumberjack_spec.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- .
+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: lumberjack-dsl
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Lumberjack is best summed up as a generic DSL for constructing object trees.
+test_files: []