cura 0.0.1

data/lib/cura/attributes/has_children.rb

@@ -0,0 +1,113 @@
+if Kernel.respond_to?(:require)
+  require "cura/component/base"
+
+  require "cura/error/invalid_component"
+end
+
+module Cura
+  module Attributes
+    
+    # Allows an object to have child components.
+    # TODO: Lots of code is the same as HasWindows
+    module HasChildren
+      
+      include Enumerable
+      
+      def initialize(*arguments)
+        @children = []
+        
+        super
+      end
+      
+      # Traverse the children of this object.
+      #
+      # @return [Array]
+      def each(&block)
+        @children.each(&block)
+      end
+      
+      # Get the children of this object.
+      #
+      # @param [Boolean] recursive Determines if the children should be gathered recursively to retrieve all of this object's decendants.
+      # @return [<Component>]
+      def children(recursive=false)
+        if recursive
+          @children.collect { |child| child.respond_to?(:children) ? [child] + child.children(true) : child }.flatten # TODO: Shouldn't flatten?
+        else
+          @children
+        end
+      end
+      
+      # Add a child to this group.
+      #
+      # @param [Component] component
+      # @return [Component]
+      def add_child(component)
+        raise TypeError, "component must be a Cura::Component" unless component.is_a?(Component::Base)
+        
+        @children << component
+        
+        component
+      end
+      
+      # Add multiple children to this group.
+      #
+      # @param [<Component>] children
+      # @return [<Component>]
+      def add_children(*children)
+        children.each { |child| add_child(child) }
+      end
+      
+      # Remove a child from this object's children at the given index.
+      #
+      # @param [#to_i] index
+      # @return [Component]
+      def delete_child_at(index)
+        @children.delete_at(index.to_i)
+      end
+      
+      # Remove a child from this object's children.
+      #
+      # @param [Component] component
+      # @return [Component]
+      def delete_child(component)
+        validate_component(component)
+
+        delete_child_at(@children.index(component))
+      end
+      
+      # Remove all children.
+      #
+      # @return [Group]
+      def delete_children
+        
+        (0...@children.count).to_a.reverse_each { |index| delete_child_at(index) } # TODO: Why reverse?
+        self
+      end
+    
+      # Determine if this group has children.
+      #
+      # @return [Boolean]
+      def children?
+        @children.any?
+      end
+      
+      protected
+      
+
+      def validate_component(component)
+        raise Error::InvalidComponent unless component.is_a?(Component::Base)
+      end
+
+      def update_children
+        children.each(&:update)
+      end
+      
+      def draw_children
+        children.each(&:draw)
+      end
+      
+    end
+    
+  end
+end

data/lib/cura/attributes/has_colors.rb

@@ -0,0 +1,66 @@
+if Kernel.respond_to?(:require)
+  require "cura/attributes/has_attributes"
+  
+  require "cura/error/invalid_color"
+  
+  require "cura/color"
+end
+
+module Cura
+  module Attributes
+    
+    # Adds the #foreground and #background attributes.
+    # TODO: Should be color and background... HasBackground and HasColor
+    module HasColors
+      
+      include HasAttributes
+      
+      def initialize(attributes={})
+        @foreground = :inherit unless instance_variable_defined?(:@foreground)
+        @background = :inherit unless instance_variable_defined?(:@background)
+        
+        super
+      end
+      
+      # @method foreground
+      # Get the foreground color of this object.
+      #
+      # @return [Color]
+      
+      # @method foreground=(value)
+      # Set the foreground color of this object.
+      #
+      # @param [Color] value
+      # @return [Color]
+      
+      attribute(:foreground) { |value| validate_color_attribute(value) }
+      
+      # @method background
+      # Get the background color of this object.
+      #
+      # @return [Color]
+      
+      # @method background=(value)
+      # Set the background color of this object.
+      #
+      # @param [Color] value
+      # @return [Color]
+      
+      attribute(:background) { |value| validate_color_attribute(value) }
+      
+      protected
+      
+      def validate_color_attribute(value)
+        unless value.is_a?(Cura::Color)
+          value = value.to_sym
+          
+          raise Error::InvalidColor unless value == :inherit
+        end
+        
+        value
+      end
+      
+    end
+    
+  end
+end

data/lib/cura/attributes/has_coordinates.rb

@@ -0,0 +1,49 @@
+if Kernel.respond_to?(:require)
+  require "cura/attributes/has_attributes"
+end
+
+module Cura
+  module Attributes
+    
+    # Adds the `x` and `y` attributes.
+    module HasCoordinates
+      
+      include HasAttributes
+      
+      def initialize(attributes={})
+        @x = 0 unless instance_variable_defined?(:@x)
+        @y = 0 unless instance_variable_defined?(:@y)
+        
+        super
+      end
+      
+      # @method x
+      # Get the X coordinate of this object.
+      #
+      # @return [Integer]
+      
+      # @method x=(value)
+      # Set the X coordinate of this object.
+      #
+      # @param [#to_i] value
+      # @return [Integer]
+      
+      attribute(:x) { |value| value.to_i }
+      
+      # @method y
+      # Get the Y coordinate of this object.
+      #
+      # @return [Integer]
+      
+      # @method y=(value)
+      # Set the Y coordinate of this object.
+      #
+      # @param [#to_i] value
+      # @return [Integer]
+      
+      attribute(:y) { |value| value.to_i }
+      
+    end
+    
+  end
+end

data/lib/cura/attributes/has_dimensions.rb

@@ -0,0 +1,63 @@
+if Kernel.respond_to?(:require)
+  require "cura/attributes/has_attributes"
+end
+
+module Cura
+  module Attributes
+    
+    # Adds the `width` and `height` attributes.
+    module HasDimensions
+      
+      include HasAttributes
+      
+      def initialize(attributes={})
+        @width = :auto unless instance_variable_defined?(:@width)
+        @height = :auto unless instance_variable_defined?(:@height)
+        
+        super
+      end
+      
+      # @method width
+      # Get the width dimension of this object.
+      #
+      # @param [#to_i] value
+      # @return [Integer]
+      
+      # @method width=(value)
+      # Set the width dimension of this object.
+      #
+      # @return [Integer]
+      
+      attribute(:width) { |value| validate_size_attribute(value) }
+      
+      # @method height
+      # Get the height dimension of this object.
+      #
+      # @return [Integer]
+      
+      # @method height=(value)
+      # Set the height dimension of this object.
+      #
+      # @param [#to_i] value
+      # @return [Integer]
+      
+      attribute(:height) { |value| validate_size_attribute(value) }
+      
+      # Set one or both of the dimensions of this object.
+      # @param [#to_h] options
+      # @option options [#to_i] :width
+      # @option options [#to_i] :height
+      # @return [Object] This object
+      def resize(options)
+        options = options.to_h
+        
+        self.width = options[:width] if options.key?(:width)
+        self.height = options[:height] if options.key?(:height)
+        
+        self
+      end
+      
+    end
+    
+  end
+end

data/lib/cura/attributes/has_events.rb

@@ -0,0 +1,89 @@
+if Kernel.respond_to?(:require)
+  require "cura/attributes/has_ancestry"
+  require "cura/event/handler"
+end
+
+module Cura
+  module Attributes
+    
+    # Adds an `event_handler` attribute as well as `callbacks` and `on_event` class methods.
+    # When subclassed, the callbacks are inherited.
+    # TODO: Rename to HasEventHandler
+    module HasEvents
+      
+      # The class methods to be mixed in when included.
+      module ClassMethods
+        
+        # The callbacks stored on this class.
+        #
+        # @return [Hash<Symbol,Array<Proc>>]
+        def callbacks
+          @callbacks ||= {}
+        end
+        
+        # Store a callback on this class.
+        # Stored callbacks will be registered on the event handler on initialization.
+        #
+        # @param [nil, #to_sym] event_name The event name.
+        # @yield The callback block.
+        # @return [Proc] The callback block.
+        def on_event(event_name=:default, &block)
+          (callbacks[event_name.to_sym] ||= []) << block
+          
+          block
+        end
+        
+        # Register this classes callbacks onto the subclass, when inherited.
+        def inherited(subclass)
+          callbacks.each do |event_name, blocks|
+            blocks.each do |block|
+              subclass.on_event(event_name, &block)
+            end
+          end
+        end
+        
+      end
+      
+      class << self
+        
+        def included(base)
+          base.send(:extend, ClassMethods)
+        end
+        
+      end
+      
+      def initialize(attributes={})
+        @event_handler = Event::Handler.new(self)
+        register_class_callbacks
+        
+        super
+      end
+      
+      # Get the event handler for this object.
+      #
+      # @return [Event::Handler]
+      attr_reader :event_handler
+      
+      # Register a callback for an event to this instance.
+      #
+      # @param [nil, #to_sym] event_name The event name.
+      # @yield The callback block.
+      # @return [Proc] The callback block.
+      def on_event(event_name=:default, *arguments, &block)
+        event_handler.register(event_name, *arguments, &block)
+      end
+      
+      protected
+      
+      def register_class_callbacks
+        self.class.callbacks.each do |event_name, blocks|
+          blocks.each do |block|
+            @event_handler.register(event_name, &block)
+          end
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/cura/attributes/has_focusability.rb

@@ -0,0 +1,37 @@
+if Kernel.respond_to?(:require)
+  require "cura/attributes/has_attributes"
+end
+
+module Cura
+  module Attributes
+    
+    # Adds the `focusable` attribute to objects.
+    module HasFocusability
+      
+      include HasAttributes
+      
+      def initialize(attributes={})
+        @focusable = false unless instance_variable_defined?(:@focusable)
+        
+        super
+      end
+      
+      # Get whether this object is focusable or not.
+      #
+      # @return [Boolean]
+      def focusable?
+        @focusable
+      end
+      
+      # Set whether this object is focusable or not.
+      #
+      # @param [Object] value
+      # @return [Boolean]
+      def focusable=(value)
+        @focusable = !!value
+      end
+      
+    end
+    
+  end
+end

data/lib/cura/attributes/has_initialize.rb

@@ -0,0 +1,15 @@
+module Cura
+  module Attributes
+    
+    # Stops the initialize super chain.
+    # Must be included before any Cura::Attributes modules which define an #initialize method.
+    module HasInitialize
+      
+      def initialize(*arguments)
+        # Blank on purpose. Carry on, my wayward son.
+      end
+      
+    end
+    
+  end
+end

data/lib/cura/attributes/has_offsets.rb

@@ -0,0 +1,82 @@
+if Kernel.respond_to?(:require)
+  require "cura/attributes/has_attributes"
+  require "cura/borders"
+  require "cura/margins"
+  require "cura/padding"
+  require "cura/offsets"
+end
+
+module Cura
+  module Attributes
+    
+    # Adds the `offsets` attribute to objects.
+    module HasOffsets
+      
+      include HasAttributes
+      
+      # @method border
+      # Get the borders of this object.
+      #
+      # @return [Borders]
+      
+      # @method border=(value)
+      # Set the borders of this object.
+      #
+      # @param [Borders, #to_h] value
+      # @return [Borders]
+      
+      attribute(:border, type: Borders) { |value, options| validate_offset_attribute(value, options[:type]) }
+      
+      # @method margin
+      # Get the margins of this object.
+      #
+      # @return [Margins]
+      
+      # @method margin=(value)
+      # Set the margins of this object.
+      #
+      # @param [Margins, #to_h] value
+      # @return [Margins]
+      
+      attribute(:margin, type: Margins) { |value, options| validate_offset_attribute(value, options[:type]) }
+      
+      # @method padding
+      # Get the padding of this object.
+      #
+      # @return [Padding]
+      
+      # @method padding=(value)
+      # Set the padding of this object.
+      #
+      # @param [Padding, #to_h] value
+      # @return [Padding]
+      
+      attribute(:padding, type: Padding) { |value, options| validate_offset_attribute(value, options[:type]) }
+      
+      def initialize(attributes={})
+        @offsets = Offsets.new(component: self)
+        
+        self.margin  = attributes[:margin]
+        self.border  = attributes[:border]
+        self.padding = attributes[:padding]
+        
+        super
+      end
+      
+      # Get the offsets of this object.
+      #
+      # @return [Offsets]
+      attr_reader :offsets
+      
+      protected
+      
+      def validate_offset_attribute(value, type)
+        value ||= {}
+        
+        value.is_a?(type) ? value : type.new(value)
+      end
+      
+    end
+    
+  end
+end