colstrom-fidgit 0.2.7

data/lib/fidgit/gosu_ext/gosu_module.rb

@@ -0,0 +1,25 @@
+module Gosu
+  class << self
+    alias_method :register_entity_fidgit, :register_entity
+
+    protected
+    def init_entities
+      @entities = {}
+    end
+
+    public
+    def register_entity(name, image)
+      name = name.to_sym
+      register_entity_fidgit(name, image)
+      @entities[name] = image
+      nil
+    end
+
+    public
+    def entity(name)
+      @entities[name.to_sym]
+    end
+  end
+
+  init_entities
+end

data/lib/fidgit/history.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+module Fidgit
+  # Manages a history of actions, along with doing, undoing and redoing those actions.
+  class History
+    # Maximum number of actions in the History before Actions are deleted.
+    DEFAULT_MAX_SIZE = 250
+
+    # An action in the History. Inherit actions from this in order to add them to a History.
+    class Action
+      # Perform the action.
+      def do; raise NotImplementedError, "#{self.class} does not have a do method defined"; end
+
+      # Reverse the action.
+      def undo; raise NotImplementedError, "#{self.class} does not have an undo method defined"; end
+    end
+
+    # Is there an action that can be undone?
+    def can_undo?; @last_done >= 0; end
+
+    # Is there an action that has been undone that can now be redone?
+    def can_redo?; @last_done < (@actions.size - 1); end
+
+    def initialize(max_size = DEFAULT_MAX_SIZE)
+      @max_size = max_size
+      @actions = []
+      @last_done = -1 # Last command that was performed.
+    end
+
+    # Perform a History::Action, adding it to the history.
+    # If there are currently any actions that have been undone, they will be permanently lost and cannot be redone.
+    #
+    # @param [History::Action] action Action to be performed
+    def do(action)
+      raise ArgumentError, "Parameter, 'action', expected to be a #{Action}, but received: #{action}" unless action.is_a? Action
+
+      # Remove all undone actions when a new one is performed.
+      if can_redo?
+        if @last_done == -1
+          @actions.clear
+        else
+          @actions = @actions[0..@last_done]
+        end
+      end
+
+      # If history is too big, remove the oldest action.
+      if @actions.size >= @max_size
+        @actions.shift
+      end
+
+      @last_done = @actions.size
+      @actions << action
+      action.do
+
+      nil
+    end
+
+    # Perform a History::Action, replacing the last action that was performed.
+    #
+    # @param [History::Action] action Action to be performed
+    def replace_last(action)
+      raise ArgumentError, "Parameter, 'action', expected to be a #{Action}, but received: #{action}" unless action.is_a? Action
+
+      @actions[@last_done].undo
+      @actions[@last_done] = action
+      action.do
+
+      nil
+    end
+
+    # Undo the last action that was performed.
+    def undo
+      raise "Can't undo unless there are commands in past" unless can_undo?
+
+      @actions[@last_done].undo
+      @last_done -= 1
+
+      nil
+    end
+
+    # Redo the last action that was undone.
+    def redo
+      raise "Can't redo if there are no commands in the future" unless can_redo?
+
+      @last_done += 1
+      @actions[@last_done].do
+
+      nil
+    end
+  end
+end

data/lib/fidgit/redirector.rb

@@ -0,0 +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
+end

data/lib/fidgit/schema.rb

@@ -0,0 +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

data/lib/fidgit/selection.rb

@@ -0,0 +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
+end

data/lib/fidgit/standard_ext/hash.rb

@@ -0,0 +1,21 @@
+class Hash
+  # Merge not only the hashes, but all nested hashes as well.
+  # Written by Stefan Rusterholz (apeiros) from http://www.ruby-forum.com/topic/142809
+  def deep_merge!(other)
+    merger = lambda do |key, a, b|
+      (a.is_a?(Hash) && b.is_a?(Hash)) ? a.merge!(b, &merger) : b
+    end
+
+    merge!(other, &merger)
+  end
+
+  # Merge not only the hashes, but all nested hashes as well.
+  # Written by Stefan Rusterholz (apeiros) from http://www.ruby-forum.com/topic/142809
+  def deep_merge(other)
+    merger = lambda do |key, a, b|
+      (a.is_a?(Hash) && b.is_a?(Hash)) ? a.merge(b, &merger) : b
+    end
+
+    merge(other, &merger)
+  end
+end