shoes-dsl 4.0.0.pre2

data/lib/shoes/sound.rb

@@ -0,0 +1,18 @@
+class Shoes
+  class Sound
+    include Common::Inspect
+
+    def initialize(parent, filepath, opts={}, &blk)
+      @parent = parent
+      @filepath = filepath
+
+      @gui = Shoes.configuration.backend_for(self)
+    end
+
+    attr_reader :gui, :filepath, :parent
+
+    def play
+      @gui.play
+    end
+  end
+end

data/lib/shoes/span.rb

@@ -0,0 +1,16 @@
+class Shoes
+  class Span < Text
+    def initialize(texts, styles={})
+      @style = styles
+      super texts, styles.delete(:color)
+    end
+
+    def style
+      if @parent_text && @parent_text.respond_to?(:style)
+        @parent_text.style.merge(@style)
+      else
+        @style
+      end
+    end
+  end
+end

data/lib/shoes/star.rb

@@ -0,0 +1,45 @@
+class Shoes
+  class Star
+    include Common::UIElement
+    include Common::Style
+    include Common::Clickable
+
+    attr_reader :app, :parent, :dimensions, :gui
+    style_with :angle, :art_styles,:common_styles, :dimensions, :inner, :outer, :points
+    STYLES = {angle: 0}
+
+    def initialize(app, parent, left, top, points, outer, inner, styles = {}, blk = nil)
+      @app = app
+      @parent = parent
+
+      # Careful not to turn Fixnum to Float, lest Dimensions make you relative!
+      width = outer*2
+
+      # Ignore calculated height on Dimensions--will force to match width
+      @dimensions = AbsoluteDimensions.new left, top, width, 0
+      @dimensions.height = @dimensions.width
+
+      # Calculate the inner dimensions, which might be relative too
+      inner_dimensions = AbsoluteDimensions.new 0, 0, inner*2, 0
+
+      # Get actual outer/inner from the dimension to handle relative values
+      outer = @dimensions.width / 2
+      inner = inner_dimensions.width / 2
+
+      # Now set style using adjust outer and inner
+      style_init(styles, inner: inner, outer: outer, points: points)
+
+      @parent.add_child self
+      @gui = Shoes.backend_for self
+
+      register_click blk
+    end
+
+    def in_bounds?(x, y)
+      dx = width / 2.0
+      dy = height / 2.0
+      left - dx <= x and x <= right - dx and top - dy <= y and y <= bottom - dy
+    end
+
+  end
+end

data/lib/shoes/text.rb

@@ -0,0 +1,24 @@
+class Shoes
+  class Text
+    include Common::Inspect
+
+    attr_reader :to_s, :texts, :color
+    attr_accessor :parent_text, :text_block
+
+    def initialize(texts, color=nil)
+      @texts       = texts
+      @color       = color
+      @to_s        = @texts.map(&:to_s).join
+      @parent_text = nil
+      @text_block  = nil
+    end
+
+    def app
+      @parent_text.app
+    end
+
+    def inspect
+      super.insert(-2, %Q| "#{to_s}"|)
+    end
+  end
+end

data/lib/shoes/text_block.rb

@@ -0,0 +1,143 @@
+class Shoes
+  CENTER = "center".freeze
+  DEFAULT_TEXTBLOCK_FONT = "Arial"
+
+  class TextBlock
+    include Common::UIElement
+    include Common::Style
+    include Common::Clickable
+    include TextBlockDimensionsDelegations
+
+    attr_reader   :gui, :parent, :text, :contents, :app, :text_styles, :dimensions
+    attr_accessor :cursor, :textcursor
+    style_with  :common_styles, :dimensions, :text_block_styles
+    STYLES = {font: "Arial"} # used in TextBlock specs only
+
+    def initialize(app, parent, text, styles = {})
+      @parent = parent
+      @app = app
+      style_init styles
+      @dimensions = TextBlockDimensions.new parent, @style
+      handle_styles @style
+      @gui = Shoes.backend_for self
+      @parent.add_child self
+
+      # Important to use accessor and do this after the backend exists!
+      self.text = Array(text)
+
+      register_click
+    end
+
+    def in_bounds?(*args)
+      @gui.in_bounds?(*args)
+    end
+
+    def text=(*texts)
+      replace *texts[0]
+    end
+
+    def replace(*texts)
+      # Order here matters as well--backend#replace shouldn't rely on DSL state
+      # but the texts that it's passed if it needs information at this point.
+      @gui.replace *texts
+
+      @text        = texts.map(&:to_s).join
+      @contents    = texts
+      @text_styles = gather_text_styles(self, texts)
+    end
+
+    def to_s
+      self.text
+    end
+
+    def contents_alignment(current_position=nil)
+      @gui.contents_alignment(current_position)
+    end
+
+    def adjust_current_position(current_position)
+      @gui.adjust_current_position(current_position)
+    end
+
+    def textcursor(line_height = 0)
+      @textcursor ||= app.textcursor(line_height)
+    end
+
+    def has_textcursor?
+      @textcursor
+    end
+
+    def centered?
+      style[:align] == CENTER
+    end
+
+    def links
+      return [] unless @contents
+
+      @contents.select do |element|
+        element.is_a?(Shoes::Link)
+      end
+    end
+
+    private
+
+    def gather_text_styles(parent_text, texts, styles={}, start_point=0)
+      texts.each do |text|
+        if text.is_a? Shoes::Text
+          text.text_block  = self
+          text.parent_text = parent_text
+          end_point        = start_point + text.to_s.length - 1
+
+          # If our endpoint is before our start, it's an empty string. We treat
+          # those specially with the (0...0) range that has an empty count.
+          if end_point < start_point
+            range = (0...0)
+          else
+            range = start_point..end_point
+          end
+
+          styles[range]    ||= []
+          styles[range] << text
+          gather_text_styles(text, text.texts, styles, start_point)
+        end
+        start_point += text.to_s.length
+      end
+      styles
+    end
+
+    def handle_styles(style)
+      parse_font_style style[:font] if style[:font] #if is needed for the specs
+    end
+
+    def parse_font_style(type)
+      size_regex = /(\d+)(\s*px)?/
+      style_regex = /none|bold|normal|oblique|italic/i # TODO: add more
+
+      font_family = type.gsub(style_regex,'').gsub(size_regex,'').
+                  split(',').map { |x| x.strip.gsub(/["]/,'') }
+
+      @style[:font] = font_family.first unless (font_family.size == 1 and
+        font_family[0] == "") or font_family.size == 0
+
+      fsize = size_regex.match(type)
+      @style[:size] = fsize[1].to_i unless fsize.nil?
+
+      # TODO: Style options
+    end
+  end
+
+  {
+    "Banner"      => { size: 48 },
+    "Title"       => { size: 34 },
+    "Subtitle"    => { size: 26 },
+    "Tagline"     => { size: 18 },
+    "Caption"     => { size: 14 },
+    "Para"        => { size: 12 },
+    "Inscription" => { size: 10 }
+  }.each do |name, styles|
+    clazz = Class.new(TextBlock) do
+      self.const_set("STYLES", { font: "Arial", fill: nil }.merge(styles))
+    end
+    Shoes.const_set(name, clazz)
+  end
+
+end

data/lib/shoes/text_block_dimensions.rb

@@ -0,0 +1,52 @@
+class Shoes
+  # We take over a bunch of the absolute_* measurements since the jagged
+  # shape of a flowed TextBlock doesn't follow the usual rules for dimensions
+  # when we get to positioning (which is the main use of these values).
+  class TextBlockDimensions < Dimensions
+    attr_writer :absolute_right, :absolute_bottom,
+                :calculated_width, :calculated_height
+
+    def absolute_right
+      @absolute_right || super
+    end
+
+    def absolute_bottom
+      @absolute_bottom || super
+    end
+
+    # It might seem weird these reverse from above, but if explicit sizes get
+    # reported verbatim, while boundaries are set by text fitting.
+    def width
+      super || @calculated_width
+    end
+
+    def height
+      super || @calculated_height
+    end
+
+    # Since we flow, try to fit in almost any space
+    def fitting_width
+      10
+    end
+
+    # This is the width the text block initially wants to try and fit into.
+    def desired_width(containing=containing_width)
+      parent.absolute_left + containing - self.absolute_left
+    end
+
+    # If an explicit width's set, use that when asking how much space we need.
+    # If not, we look to the parent.
+    def containing_width
+      element_width || parent.element_width
+    end
+  end
+
+  module TextBlockDimensionsDelegations
+    extend Forwardable
+
+    DELEGATED_METHODS = TextBlockDimensions.public_instance_methods(false)
+
+    def_delegators :dimensions, *DELEGATED_METHODS
+  end
+
+end

data/lib/shoes/timer.rb

@@ -0,0 +1,12 @@
+class Shoes
+  class Timer
+    include Common::Inspect
+
+    def initialize app, n=1000, &blk
+      @app, @n, @blk = app, n, blk
+      @gui = Shoes.configuration.backend_for(self, @app.gui, @blk)
+    end
+
+    attr_reader :n, :gui
+  end
+end

data/lib/shoes/url.rb

@@ -0,0 +1,44 @@
+class Shoes
+
+  # Backwards compatibility, kind of likely to be removed
+  def self.inherited(base_class)
+    base_class.send :include, URL #include is private, therefore send
+  end
+
+  module URL
+    attr_accessor :app
+
+    Shoes::App.subscribe_to_dsl_methods self
+
+    def self.included(base_class)
+      base_class.extend URLDefiner
+    end
+
+    def self.urls
+      @urls ||= {}
+    end
+  end
+
+  module URLDefiner
+    def url(page, method)
+      page = convert_page_to_regex(page)
+      url_class = self
+
+      Shoes::URL.urls[page] = proc do |app, arg|
+        new_url_instance = url_class.new
+        new_url_instance.app = app
+
+        if arg
+          new_url_instance.send(method, arg)
+        else
+          new_url_instance.send method
+        end
+      end
+    end
+
+    private
+    def convert_page_to_regex(page)
+      /^#{page}$/
+    end
+  end
+end

data/lib/shoes/version.rb

@@ -0,0 +1,3 @@
+class Shoes
+  VERSION = "4.0.0.pre2"
+end

data/lib/shoes/widget.rb

@@ -0,0 +1,69 @@
+class Shoes
+  # This is the superclass for creating custom Shoes widgets.
+  #
+  # To use, inherit from {Shoes::Widget}. You get a few magical effects:
+  #
+  # * When you inherit from {Shoes::Widget}, you get a method in your Apps to
+  #   create your widgets. The method is lower- and snake-cased. It returns
+  #   an instance of your widget class.
+  # * Your widgets delegate missing methods to their app object. This
+  #   allows you to use the Shoes DSL within your widgets.
+  #
+  # @example
+  #   class SayHello < Shoes::Widget
+  #     def initialize word
+  #       para "Hello #{word}", stroke: green, size: 80
+  #     end
+  #   end
+  #
+  #   Shoes.app do
+  #     say_hello 'Shoes'
+  #   end
+  #
+  class Widget
+    include Common::Inspect
+
+    Shoes::App.subscribe_to_dsl_methods self
+
+    attr_accessor :parent
+    attr_writer   :app
+
+    class << self
+      attr_accessor :app
+    end
+
+    # lookup a bit more complicated as during initialize we do
+    # not have @app yet...
+    def app
+      @app || self.class.app
+    end
+
+    def self.inherited(klass, &blk)
+      dsl_method = dsl_method_name(klass)
+      Shoes::App.new_dsl_method(dsl_method) do |*args, &blk|
+        # we set app 2 times because widgets execute most of their code
+        # straight in initialize. I dunno if there is a good way of setting
+        # an @app instance variable before initialize is executed. We could
+        # hand it over in #initialize but that would break the interface
+        # and people would have to set it themselves or make sure to call
+        # super so for not it's like this.
+        # Setting the ref on the instance is important as we might have
+        # instances of the same widget in different Shoes::Apps so each one
+        # needs to save the reference to the one it was started with
+        klass.app              = self
+        widget_instance        = klass.new(*args, &blk)
+        widget_instance.app    = self
+        widget_instance.parent = @__app__.current_slot
+        widget_instance
+      end
+    end
+
+
+    private
+    def self.dsl_method_name(klass)
+      klass.to_s[/(^|::)(\w+)$/, 2].
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
+    end
+  end
+end

data/manifests/common.rb

@@ -0,0 +1,34 @@
+require 'rake/file_list'
+
+module ShoesManifestReport
+  def report
+    puts "Manifest of #{gem_name} gem"
+    puts
+    puts "files"
+    puts "-----"
+    puts files.sort.join("\n")
+    puts
+    puts "test_files"
+    puts "----------"
+    puts test_files.sort.join("\n")
+    puts
+    puts "#{files.length} files, #{test_files.length} test_files"
+  end
+end
+
+class ShoesCommonManifest
+  def self.files
+    Rake::FileList[%w(
+      CHANGELOG
+      Gemfile
+      Guardfile
+      LICENSE
+      README.md
+      manifests/common.rb
+    )]
+  end
+
+  def self.test_files
+    []
+  end
+end