fidgit 0.2.4 → 0.2.5

data/lib/fidgit/redirector.rb

@@ -1,83 +1,83 @@
-module Fidgit
-  # Redirects methods to an object, but does not mask methods and ivars from the calling context.
-  module RedirectorMethods
-    # Evaluate a block accessing methods and ivars from the calling context, but calling public methods
-    # (not ivars or non-public methods) on this object in preference.
-    def instance_methods_eval(&block)
-      raise ArgumentError, "block required" unless block_given?
-
-      context = eval('self', block.binding)
-
-      context.send :push_redirection_target, self
-
-      begin
-        yield context
-      ensure
-        context.send :pop_redirection_target
-      end
-
-      self
-    end
-
-    protected
-    def push_redirection_target(target)
-      meta_class = class << self; self; end
-      base_methods = Object.public_instance_methods
-
-      # Redirect just the public methods of the target, less those that are on Object.
-      methods_to_redirect = target.public_methods - base_methods
-
-      # Only hide those public/private/protected methods that are being redirected.
-      methods_overridden = []
-      [:public, :protected, :private].each do |access|
-        methods_to_hide = meta_class.send("#{access}_instance_methods", false) & methods_to_redirect
-        methods_to_hide.each do |meth|
-          # Take a reference to the method we are about to override.
-          methods_overridden.push [meth, method(meth), access]
-          meta_class.send :remove_method, meth
-        end
-      end
-
-      # Add a method, to redirect calls to the target.
-      methods_to_redirect.each do |meth|
-        meta_class.send :define_method, meth do |*args, &block|
-          target.send meth, *args, &block
-        end
-      end
-
-      redirection_stack.push [target, methods_overridden, methods_to_redirect]
-
-      target
-    end
-
-    protected
-    def pop_redirection_target
-      meta_class = class << self; self; end
-
-      target, methods_to_recreate, methods_to_remove = redirection_stack.pop
-
-      # Remove the redirection methods
-      methods_to_remove.reverse_each do |meth|
-        meta_class.send :remove_method, meth
-      end
-
-      # Replace with the previous versions of the methods.
-      methods_to_recreate.reverse_each do |meth, reference, access|
-        meta_class.send :define_method, meth, reference
-        meta_class.send access, meth unless access == :public
-      end
-
-      target
-    end
-
-    # Direct access to the redirection stack.
-    private
-    def redirection_stack
-      @_redirection_stack ||= []
-    end
-  end
-end
-
-class Object
-  include Fidgit::RedirectorMethods
+module Fidgit
+  # Redirects methods to an object, but does not mask methods and ivars from the calling context.
+  module RedirectorMethods
+    # Evaluate a block accessing methods and ivars from the calling context, but calling public methods
+    # (not ivars or non-public methods) on this object in preference.
+    def instance_methods_eval(&block)
+      raise ArgumentError, "block required" unless block_given?
+
+      context = eval('self', block.binding)
+
+      context.send :push_redirection_target, self
+
+      begin
+        yield context
+      ensure
+        context.send :pop_redirection_target
+      end
+
+      self
+    end
+
+    protected
+    def push_redirection_target(target)
+      meta_class = class << self; self; end
+      base_methods = Object.public_instance_methods
+
+      # Redirect just the public methods of the target, less those that are on Object.
+      methods_to_redirect = target.public_methods - base_methods
+
+      # Only hide those public/private/protected methods that are being redirected.
+      methods_overridden = []
+      [:public, :protected, :private].each do |access|
+        methods_to_hide = meta_class.send("#{access}_instance_methods", false) & methods_to_redirect
+        methods_to_hide.each do |meth|
+          # Take a reference to the method we are about to override.
+          methods_overridden.push [meth, method(meth), access]
+          meta_class.send :remove_method, meth
+        end
+      end
+
+      # Add a method, to redirect calls to the target.
+      methods_to_redirect.each do |meth|
+        meta_class.send :define_method, meth do |*args, &block|
+          target.send meth, *args, &block
+        end
+      end
+
+      redirection_stack.push [target, methods_overridden, methods_to_redirect]
+
+      target
+    end
+
+    protected
+    def pop_redirection_target
+      meta_class = class << self; self; end
+
+      target, methods_to_recreate, methods_to_remove = redirection_stack.pop
+
+      # Remove the redirection methods
+      methods_to_remove.reverse_each do |meth|
+        meta_class.send :remove_method, meth
+      end
+
+      # Replace with the previous versions of the methods.
+      methods_to_recreate.reverse_each do |meth, reference, access|
+        meta_class.send :define_method, meth, reference
+        meta_class.send access, meth unless access == :public
+      end
+
+      target
+    end
+
+    # Direct access to the redirection stack.
+    private
+    def redirection_stack
+      @_redirection_stack ||= []
+    end
+  end
+end
+
+class Object
+  include Fidgit::RedirectorMethods
 end

data/lib/fidgit/schema.rb

@@ -1,123 +1,123 @@
-# encoding: utf-8
-
-module Fidgit
-  # An object that manages Schema values. Usually loaded from a YAML file.
-  #
-  # @example
-  #   schema = Schema.new(YAML.load(file.read('default_schema.yml')))
-  #   default_color = schema.default(Element, :disabled, :color)
-  #   schema.merge_schema!(YAML.load(file.read('override_schema.yml'))
-  #   overridden_color = schema.default(Element, :disabled, :color)
-  class Schema
-    CONSTANT_PREFIX = '?'
-
-    # @param [Hash<Symbol => Hash>] schema data containing
-    def initialize(schema)
-      @constants = {}
-      @elements = {}
-
-      merge_schema! schema
-    end
-
-    # Merge in a hash containing constant values.
-    #
-    # @param [Hash<Symbol => Hash>] constants_hash Containing :colors, :constants and :elements hashes.
-    def merge_schema!(schema)
-      merge_constants!(schema[:constants]) if schema[:constants]
-      merge_elements!(schema[:elements]) if schema[:elements]
-
-      self
-    end
-
-    # Merge in a hash containing constant values. Arrays will be resolved as colors in RGBA or RGB format.
-    #
-    # @param [Hash<Symbol => Object>] constants_hash
-    def merge_constants!(constants_hash)
-      constants_hash.each_pair do |name, value|
-        @constants[name] = case value
-        when Array
-          case value.size
-          when 3 then Gosu::Color.rgb(*value)
-          when 4 then Gosu::Color.rgba(*value)
-          else
-            raise "Colors must be in 0..255, RGB or RGBA array format"
-          end
-        else
-          value
-        end
-      end
-
-      self
-    end
-
-    # Merge in a hash containing default values for each element.
-    #
-    # @param [Hash<Symbol => Hash>] elements_hash
-    def merge_elements!(elements_hash)
-      elements_hash.each_pair do |klass_names, data|
-        klass = Fidgit
-        klass_names.to_s.split('::').each do |klass_name|
-          klass = klass.const_get klass_name
-        end
-
-        raise "elements must be names of classes derived from #{Element}" unless klass.ancestors.include? Fidgit::Element
-        @elements[klass] ||= {}
-        @elements[klass].deep_merge! data
-      end
-
-      self
-    end
-
-    # Get the constant value associated with +name+.
-    #
-    # @param [Symbol] name
-    # @return [Object]
-    def constant(name)
-      @constants[name]
-    end
-
-    # @param [Class] klass Class to look for defaults for.
-    # @param [Symbol, Array<Symbol>] names Hash names to search for in that class's schema.
-    def default(klass, names)
-      raise ArgumentError, "#{klass} is not a descendent of the #{Element} class" unless klass.ancestors.include? Element
-      value = default_internal(klass, Array(names), true)
-      raise("Failed to find named value #{names.inspect} for class #{klass}") unless value
-      value
-    end
-
-    protected
-    # @param [Class] klass Class to look for defaults for.
-    # @param [Array<Symbol>] names Hash names to search for in that class's schema.
-    # @param [Boolean] default_to_outer Whether to default to an outer value (used internally)
-    def default_internal(klass, names, default_to_outer)
-      # Find the value by moving through the nested hash via the names.
-      value = @elements[klass]
-
-      names.each do |name|
-        break unless value.is_a? Hash
-        value = value.has_key?(name) ? value[name] : nil
-      end
-
-      # Convert the value to a color/constant if they are symbols.
-      value = if value.is_a? String and value[0] == CONSTANT_PREFIX
-          str = value[1..-1]
-          constant(str.to_sym) || value # If the value isn't a constant, return the string.
-        else
-          value
-      end
-
-      # If we didn't find the value for this class, default to parent class value.
-      if value.nil? and klass != Element and klass.ancestors.include? Element
-        # Check if any ancestors define the fully named value.
-        value = default_internal(klass.superclass, names, false)
-      end
-
-      if value.nil? and default_to_outer and names.size > 1
-        # Check the outer values (e.g. if [:hover, :color] is not defined, try [:color]).
-        value = default_internal(klass, names[1..-1], true)
-      end
-
-      value
-    end
-  end
-end
+# encoding: utf-8
+
+module Fidgit
+  # An object that manages Schema values. Usually loaded from a YAML file.
+  #
+  # @example
+  #   schema = Schema.new(YAML.load(file.read('default_schema.yml')))
+  #   default_color = schema.default(Element, :disabled, :color)
+  #   schema.merge_schema!(YAML.load(file.read('override_schema.yml'))
+  #   overridden_color = schema.default(Element, :disabled, :color)
+  class Schema
+    CONSTANT_PREFIX = '?'
+
+    # @param [Hash<Symbol => Hash>] schema data containing
+    def initialize(schema)
+      @constants = {}
+      @elements = {}
+
+      merge_schema! schema
+    end
+
+    # Merge in a hash containing constant values.
+    #
+    # @param [Hash<Symbol => Hash>] constants_hash Containing :colors, :constants and :elements hashes.
+    def merge_schema!(schema)
+      merge_constants!(schema[:constants]) if schema[:constants]
+      merge_elements!(schema[:elements]) if schema[:elements]
+
+      self
+    end
+
+    # Merge in a hash containing constant values. Arrays will be resolved as colors in RGBA or RGB format.
+    #
+    # @param [Hash<Symbol => Object>] constants_hash
+    def merge_constants!(constants_hash)
+      constants_hash.each_pair do |name, value|
+        @constants[name] = case value
+        when Array
+          case value.size
+          when 3 then Gosu::Color.rgb(*value)
+          when 4 then Gosu::Color.rgba(*value)
+          else
+            raise "Colors must be in 0..255, RGB or RGBA array format"
+          end
+        else
+          value
+        end
+      end
+
+      self
+    end
+
+    # Merge in a hash containing default values for each element.
+    #
+    # @param [Hash<Symbol => Hash>] elements_hash
+    def merge_elements!(elements_hash)
+      elements_hash.each_pair do |klass_names, data|
+        klass = Fidgit
+        klass_names.to_s.split('::').each do |klass_name|
+          klass = klass.const_get klass_name
+        end
+
+        raise "elements must be names of classes derived from #{Element}" unless klass.ancestors.include? Fidgit::Element
+        @elements[klass] ||= {}
+        @elements[klass].deep_merge! data
+      end
+
+      self
+    end
+
+    # Get the constant value associated with +name+.
+    #
+    # @param [Symbol] name
+    # @return [Object]
+    def constant(name)
+      @constants[name]
+    end
+
+    # @param [Class] klass Class to look for defaults for.
+    # @param [Symbol, Array<Symbol>] names Hash names to search for in that class's schema.
+    def default(klass, names)
+      raise ArgumentError, "#{klass} is not a descendent of the #{Element} class" unless klass.ancestors.include? Element
+      value = default_internal(klass, Array(names), true)
+      raise("Failed to find named value #{names.inspect} for class #{klass}") unless value
+      value
+    end
+
+    protected
+    # @param [Class] klass Class to look for defaults for.
+    # @param [Array<Symbol>] names Hash names to search for in that class's schema.
+    # @param [Boolean] default_to_outer Whether to default to an outer value (used internally)
+    def default_internal(klass, names, default_to_outer)
+      # Find the value by moving through the nested hash via the names.
+      value = @elements[klass]
+
+      names.each do |name|
+        break unless value.is_a? Hash
+        value = value.has_key?(name) ? value[name] : nil
+      end
+
+      # Convert the value to a color/constant if they are symbols.
+      value = if value.is_a? String and value[0] == CONSTANT_PREFIX
+          str = value[1..-1]
+          constant(str.to_sym) || value # If the value isn't a constant, return the string.
+        else
+          value
+      end
+
+      # If we didn't find the value for this class, default to parent class value.
+      if value.nil? and klass != Element and klass.ancestors.include? Element
+        # Check if any ancestors define the fully named value.
+        value = default_internal(klass.superclass, names, false)
+      end
+
+      if value.nil? and default_to_outer and names.size > 1
+        # Check the outer values (e.g. if [:hover, :color] is not defined, try [:color]).
+        value = default_internal(klass, names[1..-1], true)
+      end
+
+      value
+    end
+  end
+end

data/lib/fidgit/selection.rb

@@ -1,106 +1,106 @@
-# encoding: utf-8
-
-module Fidgit
-  class Selection
-    MIN_DRAG_DISTANCE = 2
-
-    def size; @items.size; end
-    def empty?; @items.empty?; end
-    def [](index); @items[index]; end
-    def each(&block); @items.each(&block); end
-    def to_a; @items.dup; end
-    def include?(object); @items.include? object; end
-
-    # Current being dragged?
-    def dragging?; @dragging; end
-
-    # Actually moved during a dragging operation?
-    def moved?; @moved; end
-
-    def initialize
-      @items = []
-      @moved = false
-      @dragging = false
-    end
-
-    def add(object)
-      object.selected = true
-      @items.push(object)
-
-      self
-    end
-
-    def remove(object)
-      @items.delete(object)
-      object.selected = false
-      object.dragging = false
-
-      self
-    end
-
-    def clear
-      end_drag if dragging?
-      @items.each { |o| o.selected = false; o.dragging = false }
-      @items.clear
-
-      self
-    end
-
-    def begin_drag(x, y)
-      @initial_x, @initial_y = x, y
-      @last_x, @last_y = x, y
-      @dragging = true
-      @moved = false
-
-      self
-    end
-
-    def end_drag
-      @items.each do |object|
-        object.x, object.y = object.x.round, object.y.round
-        object.dragging = false
-      end
-      @dragging = false
-      @moved = false
-
-      self
-    end
-
-    # Move all dragged object back to original positions.
-    def reset_drag
-      if moved?
-        @items.each do |o|
-          o.x += @initial_x - @last_x
-          o.y += @initial_y - @last_y
-        end
-      end
-
-      self.end_drag
-
-      self
-    end
-
-    def update_drag(x, y)
-      x, y = x.round, y.round
-
-      # If the mouse has been dragged far enough from the initial click position, then 'pick up' the objects and drag.
-      unless moved?
-        if distance(@initial_x, @initial_y, x, y) > MIN_DRAG_DISTANCE
-          @items.each { |o| o.dragging = true }
-          @moved = true
-        end
-      end
-
-      if moved?
-        @items.each do |o|
-          o.x += x - @last_x
-          o.y += y - @last_y
-        end
-
-        @last_x, @last_y = x, y
-      end
-
-      self
-    end
-  end
+# encoding: utf-8
+
+module Fidgit
+  class Selection
+    MIN_DRAG_DISTANCE = 2
+
+    def size; @items.size; end
+    def empty?; @items.empty?; end
+    def [](index); @items[index]; end
+    def each(&block); @items.each(&block); end
+    def to_a; @items.dup; end
+    def include?(object); @items.include? object; end
+
+    # Current being dragged?
+    def dragging?; @dragging; end
+
+    # Actually moved during a dragging operation?
+    def moved?; @moved; end
+
+    def initialize
+      @items = []
+      @moved = false
+      @dragging = false
+    end
+
+    def add(object)
+      object.selected = true
+      @items.push(object)
+
+      self
+    end
+
+    def remove(object)
+      @items.delete(object)
+      object.selected = false
+      object.dragging = false
+
+      self
+    end
+
+    def clear
+      end_drag if dragging?
+      @items.each { |o| o.selected = false; o.dragging = false }
+      @items.clear
+
+      self
+    end
+
+    def begin_drag(x, y)
+      @initial_x, @initial_y = x, y
+      @last_x, @last_y = x, y
+      @dragging = true
+      @moved = false
+
+      self
+    end
+
+    def end_drag
+      @items.each do |object|
+        object.x, object.y = object.x.round, object.y.round
+        object.dragging = false
+      end
+      @dragging = false
+      @moved = false
+
+      self
+    end
+
+    # Move all dragged object back to original positions.
+    def reset_drag
+      if moved?
+        @items.each do |o|
+          o.x += @initial_x - @last_x
+          o.y += @initial_y - @last_y
+        end
+      end
+
+      self.end_drag
+
+      self
+    end
+
+    def update_drag(x, y)
+      x, y = x.round, y.round
+
+      # If the mouse has been dragged far enough from the initial click position, then 'pick up' the objects and drag.
+      unless moved?
+        if distance(@initial_x, @initial_y, x, y) > MIN_DRAG_DISTANCE
+          @items.each { |o| o.dragging = true }
+          @moved = true
+        end
+      end
+
+      if moved?
+        @items.each do |o|
+          o.x += x - @last_x
+          o.y += y - @last_y
+        end
+
+        @last_x, @last_y = x, y
+      end
+
+      self
+    end
+  end
 end