engineering 0.2 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: edf0dffae8854098af2df322958e8540d05676a2
-  data.tar.gz: f1a408fab212a5268b6a10f81117dd9c5be3c6c1
+  metadata.gz: 77f2d000480b81c235ca318065fa10b03ae24c53
+  data.tar.gz: 7079726edaaa3a2c4861f91170a2522b298a0882
 SHA512:
-  metadata.gz: 8427c54453c06709181a6ac2f8c7480af92bab90c4a59dd8482bdc6f5d20770acf13204b82cc1facb74259cd39ef16255796ce37e081725f78b640f8fd6ae042
-  data.tar.gz: 406eb9aa3eb061de7b520f6e6c1ddbced71fa279aec59c7c2e18312f9a6a9c2457cb3e94cbbafb6d3cd65dfd965fbb53efa779f2f647b1e8bcce675fc05447d5
+  metadata.gz: 27e226858c03ed4213db6d169386886f6492aec85c8ca60d9d9ad70d0148391af909741443359ef3481ba816e9cc36c4a1c3dae21030e3e68126fe022b839fe1
+  data.tar.gz: dd254bd2ede34af0ab21f9635c3e4c92b4e1ac32be27423736f401641df720bad14484e3a4dd4857d20a4a369e23da3876897a77568cbab3ad0e5743e6d8452a

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+- 2.0.0
+deploy:
+  provider: rubygems
+  api_key:
+    secure: VCPQ9R1RYDhW68CT/P84RvNFbMzI3PsU8K0dFThhr5D2QcpRZTZTW6OeQIpToMdpvFny6Dpu7xa9I+wNFEuMYGIXXlLNirPkhNpu8iBCgarP1QoW173sNNhT8gCjhJrY2QmWFMjH//smMSZHfoJ0cO06/7246/9qK9171C8Lo0E=
+  gem: engineering
+  on:
+    tags: true
+    repo: bfoz/engineering

data/Gemfile

@@ -1,7 +1,11 @@
 source "http://rubygems.org"
 
-# Specify your gem's dependencies in engineering.gemspec
 gemspec
 
 gem 'model', github: 'bfoz/model'
-gem 'units', github: 'bfoz/units-ruby
+gem 'sketch', github: 'bfoz/sketch'
+gem 'units', github: 'bfoz/units-ruby'
+
+group :test do
+    gem 'rake'
+end

data/Rakefile

@@ -1,6 +1,8 @@
 require "bundler/gem_tasks"
 require 'rake/testtask'
 
+task :default => :test
+
 Rake::TestTask.new do |t|
     t.libs.push "lib"
     t.test_files = FileList['test/**/*.rb']

data/engineering.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
     s.name        = "engineering"
-    s.version     = '0.2'
+    s.version     = '0.3'
     s.authors     = ["Brandon Fosdick"]
     s.email       = ["bfoz@bfoz.net"]
     s.homepage    = "http://github.com/bfoz/engineering"
@@ -17,9 +17,11 @@ Gem::Specification.new do |s|
     s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
     s.require_paths = ["lib"]
 
-    s.add_dependency	'dxf', '~> 0.2'
-    s.add_dependency	'geometry', '~> 6.1'
-    s.add_dependency	'model', '~> 0.1'
-    s.add_dependency	'sketch', '~> 0.2'
-    s.add_dependency	'units', '~> 2.2'
+    s.add_dependency	'dxf', '~> 0.3'
+    s.add_dependency	'geometry', '~> 6.4'
+    s.add_dependency	'model', '~> 0.2'
+    s.add_dependency	'sketch', '~> 0.4'
+    s.add_dependency	'units', '~> 2.4'
+
+    s.required_ruby_version = '>= 2.0'
 end

data/lib/builder/extrusion.rb

@@ -0,0 +1,189 @@
+require 'model/extrusion'
+
+require_relative 'sketch'
+
+module Engineering
+    module Builder
+	# Build an {Extrusion} subclass
+	class Extrusion
+	    include ::Sketch::DSL
+
+	    # Convenience method for creating a new builder and evaluating a block
+	    def self.build(&block)
+		self.new.build(&block)
+	    end
+
+	    def initialize
+		@attribute_defaults = {}
+	    end
+
+	    # Evaluate a block in the context of an {Extrusion} and a {Skecth}
+	    #  Use the trick found here http://www.dan-manges.com/blog/ruby-dsls-instance-eval-with-delegation
+	    #  to allow the DSL block to call methods in the enclosing *lexical* scope
+	    def build(&block)
+		@klass = Class.new(::Model::Extrusion)
+		@sketch_klass = Class.new(::Sketch)
+
+		@klass.singleton_class.send :attr_accessor, :sketch
+		@klass.instance_variable_set('@sketch', @sketch_klass)
+
+		if block_given?
+		    # So that #push has something to append to
+		    @sketch_klass.singleton_class.send :attr_accessor, :elements
+		    @sketch_klass.instance_variable_set('@elements', [])
+
+		    @self_before_instance_eval = block.binding.eval('self')
+		    self.instance_eval(&block)
+
+		    # Instance variable values for read-only attributes need special handling
+		    setter_defaults = @attribute_defaults.select {|k,v| @sketch_klass.respond_to? k.to_s + '=' } # Find the ones that can be set normally
+		    instance_variable_defaults = @attribute_defaults.reject {|k,v| @sketch_klass.respond_to? k.to_s + '=' }	# These must be set directly
+
+		    # The new Sketch subclass needs an initializer too
+		    @sketch_klass.send :define_method, :initialize do |*args, &block|
+			# Directly set the read-only instance variables
+			instance_variable_defaults.each {|k,v| instance_variable_set('@' + k.to_s, v) }
+
+			super(*args, &block)
+
+			# Push the default geometry
+			self.class.instance_variable_get(:@elements).each do |a|
+			    if a.is_a? Array
+				push a.first.new(*a.last)
+			    else
+				push a
+			    end
+			end
+		    end
+
+		    @klass.send :define_method, :initialize do |options={}, &block|
+			raise ArgumentError, "Can't initialize with a length when #{self} already has a length attribute" if self.class.length and options.key?(:length)
+			raise ArgumentError, "Can't initialize with a Sketch when #{self} already has a Sketch attribute" if self.class.sketch and options.key?(:sketch)
+
+			# Sketch doesn't support any Transformation options
+			sketch_options = options.reject {|k,v| [:angle, :origin, :translate, :x, :y].include? k }
+			# More things that Sketch can't handle
+			sketch_options.reject! {|k,v| [:length, :sketch].include? k }
+
+			# Evaluate any blocks in the passed arguments and dupe the options
+			#  hash as a side effect so that the caller's hash isn't mutated
+			options = (options.map {|k,v| { k => (v.respond_to?(:call) ? v.call : v) } }).reduce(:merge) || {}
+
+			# Create a new instance of the Sketch subclass
+			options[:sketch] = self.class.sketch.new(setter_defaults.merge(sketch_options)) if self.class.sketch
+			options[:length] = self.class.length if self.class.length
+
+			super options
+		    end
+		end
+
+		@klass.singleton_class.send :attr_accessor, :length
+		@klass.instance_variable_set('@length', @length)
+
+		@klass
+	    end
+
+	    # The second half of the instance_eval delegation trick mentioned at
+	    #   http://www.dan-manges.com/blog/ruby-dsls-instance-eval-with-delegation
+	    def method_missing(method, *args, &block)
+		if @klass.respond_to? method
+		    @klass.send method, *args, &block
+		elsif @sketch_klass.respond_to? method
+		    @sketch_klass.send method, *args, &block
+		else
+		    @self_before_instance_eval.send method, *args, &block
+		end
+	    end
+
+# @group DSL support methods
+
+private
+
+	    # Set the length attribute of the {Extrusion}
+	    # @param length [Number]	the new length
+	    def length(length=nil)
+		@length = length if length
+		@length
+	    end
+
+	    # Create a {Group} with an optional transformation
+	    def build_group(*args, &block)
+		[Builder::Sketch.new.build(::Sketch::Group, &block), args]
+	    end
+
+	    # Create a {Layout}
+	    # @param direction [Symbol] The layout direction (either :horizontal or :vertical)
+	    # @option options [Symbol] alignment    :top, :bottom, :left, or :right
+	    # @option options [Number] spacing  The spacing between each element
+	    def build_layout(direction, alignment, spacing, *args, &block)
+		[Builder::Sketch.new.build(::Sketch::Layout, &block), args]
+	    end
+
+	    # Use the given block to build a {Polyline}
+	    def build_polyline(**options, &block)
+		::Sketch::Builder::Polyline.new(**options).evaluate(&block)
+	    end
+
+	    # Build a {Polygon} from a block
+	    # @return [Polygon]
+	    def build_polygon(**options, &block)
+		::Sketch::Builder::Polygon.new(**options).evaluate(&block)
+	    end
+
+	    # Define an attribute with the given name and optional default value (or block)
+	    # @param name [String]	The attribute's name
+	    # @param value An optional default value
+	    def define_attribute_reader(name, value=nil, &block)
+		name, value = name.flatten if name.is_a?(Hash)
+		name = name.to_sym
+
+		# Class accessor that forwards to the Sketch
+		@klass.class_eval "class << self; def #{name}; sketch.#{name}; end; end"
+
+		# Instance accessor that forwards to the Sketch
+		@klass.send :define_method, name.to_sym do
+		    sketch.send name
+		end
+
+		# Instance accessor on the new Sketch
+		@sketch_klass.send :attr_reader, name
+
+		if value || block_given?
+		    # Class accessor on the new Sketch subclass
+		    @sketch_klass.singleton_class.send :attr_reader, name
+
+		    # Set the ivar on the Sketch subclass
+		    @sketch_klass.instance_variable_set('@' + name.to_s, value || instance_eval(&block))
+		    @attribute_defaults[name] = value || block
+		end
+	    end
+
+	    # Define an attribute with the given name
+	    # @param name [String,Symbol]   the name of the attribute
+	    def define_attribute_writer(name)
+		method_name = name.to_s + '='
+
+		# Class accessor that forwards to the Sketch
+		@klass.class_eval "class << self; def #{method_name}(value); sketch.#{method_name} value; end; end"
+
+		# Instance accessor that forwards to the Sketch
+		@klass.send :define_method, method_name.to_sym do |value|
+		    sketch.send method_name, value
+		end
+
+		# Instance accessor on the new Sketch
+		@sketch_klass.send :attr_writer, name.to_sym
+	    end
+
+	    # Append a new object (with optional transformation) to the {Sketch}
+	    def push(element, *args)
+		if element.is_a? Class
+		    @sketch_klass.instance_variable_get(:@elements).push [element, args]
+		else
+		    @sketch_klass.instance_variable_get(:@elements).push element
+		end
+	    end
+# @endgroup
+	end
+    end
+end

data/lib/builder/model.rb

@@ -0,0 +1,120 @@
+require 'model'
+
+require_relative '../model/dsl'
+require_relative 'extrusion'
+
+module Engineering
+    module Builder
+	# Build a {Model} subclass
+	class Model
+	    include ::Model::DSL
+
+	    # Convenience method for creating a new builder and evaluating a block
+	    def self.build(&block)
+		self.new.build(&block)
+	    end
+
+	    def initialize
+		@attribute_defaults = {}
+	    end
+
+	    # Evaluate a block and return a new {Model} subclass
+	    #  Use the trick found here http://www.dan-manges.com/blog/ruby-dsls-instance-eval-with-delegation
+	    #  to allow the DSL block to call methods in the enclosing *lexical* scope
+	    def build(super_class=::Model, &block)
+		@klass = Class.new(super_class)
+		if block_given?
+		    @klass.singleton_class.send :attr_reader, :elements
+		    @klass.instance_variable_set(:@elements, [])
+
+		    @self_before_instance_eval = block.binding.eval('self')
+		    self.instance_eval(&block)
+
+		    # Instance variable values for read-only attributes need special handling
+		    options = @attribute_defaults.select {|k,v| @klass.respond_to? k.to_s + '=' } # Find the ones that can be set normally
+		    instance_variable_defaults = @attribute_defaults.reject {|k,v| @klass.respond_to? k.to_s + '=' }	# These must be set directly
+
+		    @klass.send :define_method, :initialize do |*args, &block|
+			# Directly set the read-only instance variables
+			instance_variable_defaults.each {|k,v| instance_variable_set('@' + k.to_s, v) }
+
+			# Handle the others normally, while evaluating any blocks
+			super(*(options.map {|k,v| { k => (v.respond_to?(:call) ? v.call : v) } }), *args, &block)
+
+			# Push the default geometry
+			self.class.instance_variable_get(:@elements).each do |a|
+			    if a.is_a? Array
+				push a.first.new(*a.last)
+			    else
+				push a
+			    end
+			end
+		    end
+		end
+		@klass
+	    end
+
+	    # The second half of the instance_eval delegation trick mentioned at
+	    #   http://www.dan-manges.com/blog/ruby-dsls-instance-eval-with-delegation
+	    def method_missing(method, *args, &block)
+		if @klass.respond_to? method
+		    @klass.send method, *args, &block
+		else
+		    @self_before_instance_eval.send method, *args, &block
+		end
+	    end
+
+# @group DSL support methods
+private
+
+	    # Build a new {Extrusion} subclass
+	    # @param length [Number]    the length of the extrusion
+	    # @param sketch [Sketch]    a {Sketch} subclass to extrude (or nil)
+	    # @param parent [Object]    a parent context to use while building
+	    # @param options [Hash]	    anything that needs to be passed to the new {Extrusion} instance
+	    def build_extrusion(length, sketch, parent, options={}, &block)
+		[Builder::Extrusion.build(&block), [options.merge(length:length)]]
+	    end
+
+	    # Build a new {Group} subclass
+	    def build_group(*args, &block)
+		[self.class.new.build(::Model::Group, &block), args]
+	    end
+
+	    # Define an attribute with the given name and optional default value (or block)
+	    # @param name [String]	The attribute's name
+	    # @param value An optional default value
+	    def define_attribute_reader(name, value=nil, &block)
+		name, value = name.flatten if name.is_a?(Hash)
+		ivar_name = '@' + name.to_s
+		name = name.to_sym
+
+		# Class accessor
+		@klass.singleton_class.send :attr_reader, name
+
+		@klass.send :attr_reader, name.to_sym	    # Instance accessor
+		if value || block_given?
+		    @klass.instance_variable_set(ivar_name, value || instance_eval(&block))
+		    @attribute_defaults[name] = value || block
+		end
+	    end
+
+	    # Define an attribute with the given name
+	    # @param name [String,Symbol]   the name of the attribute
+	    def define_attribute_writer(name)
+		@klass.send :attr_writer, name.to_sym	    # Instance accessor
+	    end
+
+	    def push(element, *args)
+		if element.is_a? Class
+		    @klass.instance_variable_get(:@elements).push [element, args]
+		elsif element.is_a?(Array) and element.first.is_a?(Class)
+		    @klass.instance_variable_get(:@elements).push element
+		else
+		    raise ArgumentError, "Can't push instances while building a class"
+		end
+	    end
+# @endgroup
+	end
+    end
+end

data/lib/builder/sketch.rb

@@ -0,0 +1,119 @@
+require 'sketch'
+
+module Engineering
+    module Builder
+	class Sketch
+	    include ::Sketch::DSL
+
+	    # Convenience method for creating a new builder and evaluating a block
+	    def self.build(&block)
+		self.new.build(&block)
+	    end
+
+	    def initialize
+		@attribute_defaults = {}
+	    end
+
+	    # Evaluate a block and return a new {Model} subclass
+	    #  Use the trick found here http://www.dan-manges.com/blog/ruby-dsls-instance-eval-with-delegation
+	    #  to allow the DSL block to call methods in the enclosing *lexical* scope
+	    def build(super_class=::Sketch, &block)
+		@klass = Class.new(super_class)
+		if block_given?
+		    @klass.singleton_class.send :attr_accessor, :elements
+		    @klass.instance_variable_set('@elements', [])
+
+		    @self_before_instance_eval = block.binding.eval('self')
+		    self.instance_eval(&block)
+
+		    # Instance variable values for read-only attributes need special handling
+		    setter_defaults = @attribute_defaults.select {|k,v| @klass.respond_to? k.to_s + '=' } # Find the ones that can be set normally
+		    instance_variable_defaults = @attribute_defaults.reject {|k,v| @klass.respond_to? k.to_s + '=' }	# These must be set directly
+
+		    @klass.send :define_method, :initialize do |*args, &block|
+			# Directly set the read-only instance variables
+			instance_variable_defaults.each {|k,v| instance_variable_set('@' + k.to_s, v) }
+
+			super(setter_defaults, *args, &block)
+
+			# Push the default geometry
+			self.class.instance_variable_get(:@elements).each do |a|
+			    if a.is_a? Array
+				push a.first.new(*a.last)
+			    else
+				push a
+			    end
+			end
+		    end
+		end
+		@klass
+	    end
+
+	    # The second half of the instance_eval delegation trick mentioned at
+	    #   http://www.dan-manges.com/blog/ruby-dsls-instance-eval-with-delegation
+	    def method_missing(method, *args, &block)
+		@self_before_instance_eval.send method, *args, &block
+	    end
+
+# @group DSL support methods
+private
+
+	    # Create a {Group} with an optional transformation
+	    def build_group(*args, &block)
+		[self.class.new.build(::Sketch::Group, &block), args]
+	    end
+
+	    # Create a {Layout}
+	    # @param direction [Symbol] The layout direction (either :horizontal or :vertical)
+	    # @option options [Symbol] alignment    :top, :bottom, :left, or :right
+	    # @option options [Number] spacing  The spacing between each element
+	    def build_layout(direction, alignment, spacing, *args, &block)
+		[Builder::Sketch.new.build(::Sketch::Layout, &block), args]
+	    end
+
+	    # Use the given block to build a {Polyline}
+	    def build_polyline(**options, &block)
+		::Sketch::Builder::Polyline.new(**options).evaluate(&block)
+	    end
+
+	    # Build a {Polygon} from a block
+	    # @return [Polygon]
+	    def build_polygon(**options, &block)
+		::Sketch::Builder::Polygon.new(**options).evaluate(&block)
+	    end
+
+	    # Define an attribute with the given name and optional default value (or block)
+	    # @param name [String]	The attribute's name
+	    # @param value An optional default value
+	    def define_attribute_reader(name, value=nil, &block)
+		name, value = name.flatten if name.is_a?(Hash)
+		ivar_name = '@' + name.to_s
+		name = name.to_sym
+
+		# Class accessor
+		@klass.class_eval "class << self; attr_reader :#{name}; end"
+
+		@klass.send :attr_reader, name.to_sym	    # Instance accessor
+		if value || block_given?
+		    @klass.instance_variable_set(ivar_name, value || instance_eval(&block))
+		    @attribute_defaults[name] = value || block
+		end
+	    end
+
+	    # Define an attribute with the given name
+	    # @param name [String,Symbol]   the name of the attribute
+	    def define_attribute_writer(name)
+		@klass.send :attr_writer, name.to_sym	    # Instance accessor
+	    end
+
+	    def push(element, *args)
+		if element.is_a? Class
+		    @klass.instance_variable_get(:@elements).push [element, args]
+		else
+		    @klass.instance_variable_get(:@elements).push element
+		end
+	    end
+# @endgroup
+	end
+    end
+end