teacup 0.0.1.pre

data/lib/teacup/style_sheet.rb

@@ -0,0 +1,195 @@
+module Teacup
+  # Stylesheets in Teacup act as a central configuration mechanism,
+  # they have two aims:
+  #
+  # 1. Allow you to store "Details" away from the main body of your code.
+  #    (controllers shouldn't have to be filled with style rules)
+  # 2. Allow you to easily re-use configuration in many places.
+  #
+  # The API really provides only two methods, {Stylesheet#style} to store properties
+  # on the Stylesheet; and {Stylesheet#query} to get them out again:
+  #
+  # @example
+  #   stylesheet = Teacup::Stylesheet.new
+  #   stylesheet.style :buttons, :corners => :rounded
+  #   # => nil
+  #   stylesheet.query :buttons
+  #   # => {:corners => :rounded}
+  #
+  # In addition to this, two separate mechanisms are provided for sharing
+  # configuration within stylesheets.
+  #
+  # Firstly, if you set the ':extends' property for a given stylename, then on lookup
+  # the Stylesheet will merge the properties for the ':extends' stylename into the return
+  # value. Conflicts are resolved so that properties with the original stylename
+  # are resolved in its favour.
+  #
+  # @example
+  #   Teacup::Stylesheet.new(:IPad) do
+  #     style :button,
+  #       background: UIColor.blackColor,
+  #       top: 100
+  #
+  #     style :ok_button, extends: :button,
+  #       title: "OK!",
+  #       top: 200
+  #
+  #   end
+  #   Teacup::Stylesheet::IPad.query(:ok_button)
+  #   # => {background: UIColor.blackColor, top: 200, title: "OK!"}
+  #
+  # Secondly, you can import Stylesheets into each other, in exactly the same way as you
+  # can include Modules into each other in Ruby. This allows you to share rules between
+  # Stylesheets.
+  #
+  # As you'd expect, conflicts are resolve so that the Stylesheet on which you call query
+  # has the highest precedence.
+  #
+  # @example
+  #   Teacup::Stylesheet.new(:IPad) do
+  #     style :ok_button,
+  #       title: "OK!"
+  #   end
+  #
+  #   Teacup::Stylesheet.new(:IPadVertical) do
+  #     import :IPad
+  #     style :ok_button,
+  #       width: 80
+  #   end
+  #   Teacup::Stylesheet::IPadVertical.query(:ok_button)
+  #   # => {title: "OK!", width: 80}
+  #
+  # The two merging mechanisms are considered independently, so you can override
+  # a property both in a ':extends' rule, and also in an imported Stylesheet. In such a
+  # a case the Stylesheet inclusion conflicts are resolved independently; and then in
+  # a second phase, the ':extends' chain is flattened.
+  #
+  class Stylesheet
+    attr_reader :name
+
+    # Create a new Stylesheet with the given name.
+    #
+    # @param name, The name to give.
+    # @param &block, The body of the Stylesheet instance_eval'd.
+    # @example
+    #   Teacup::Stylesheet.new(:IPadVertical) do
+    #     import :IPadBase
+    #     style :continue_button,
+    #        top: 50
+    #   end
+    #
+    def initialize(name, &block)
+      @name = name.to_sym
+      Teacup::Stylesheet.const_set(@name, self)
+      instance_eval &block
+      self
+    end
+
+    # Include another Stylesheet into this one, the rules defined
+    # within it will have lower precedence than those defined here
+    # in the case that they share the same keys.
+    #
+    # @param Symbol the name of the stylesheet.
+    # @example
+    #   Teacup::Stylesheet.new(:IPadVertical) do
+    #     import :IPadBase
+    #     import :VerticalTweaks
+    #   end
+    def import(name_or_stylesheet)
+      if Stylesheet === name_or_stylesheet
+        imported << name_or_stylesheet.name
+      else
+        imported << name_or_stylesheet.to_sym
+      end
+    end
+
+    # Add a set of properties for a given stylename or set of stylenames.
+    #
+    # @param Symbol, *stylename
+    # @param Hash[Symbol, Object], properties
+    # @example
+    #   Teacup::Stylesheet.new(:IPadBase) do
+    #     style :pretty_button,
+    #       backgroundColor: UIColor.blackColor
+    #
+    #     style :continue_button, extends: :pretty_button,
+    #       title: "Continue!",
+    #       top: 50
+    #   end
+    def style(*queries)
+      properties = queries.pop
+      queries.each do |stylename|
+        styles[stylename].update(properties)
+      end
+    end
+
+    # Get the properties defined for the given stylename, in this Stylesheet and all
+    # those that have been imported.
+    #
+    # If the ':extends' property is set, we then repeat the process with the value
+    # of that, and include them into the result with lower precedence.
+    #
+    # @param Symbol stylename, the stylename to look up.
+    # @return Hash[Symbol, *] the resulting properties.
+    # @example
+    #   Teacup::Stylesheet::IPadBase.query(:continue_button)
+    #   # => {backgroundColor: UIColor.blackColor, title: "Continue!", top: 50}
+    def query(stylename)
+      this_rule = properties_for(stylename)
+
+      if also_include = this_rule.delete(:extends)
+        query(also_include).merge(this_rule)
+      else
+        this_rule
+      end
+    end
+
+    # A unique and hopefully meaningful description of this Object.
+    #
+    # @return String
+    def inspect
+      "Teacup::Stylesheet:#{name.inspect}"
+    end
+
+    protected
+
+    # Get the properties for a given stylename, including any properties
+    # defined on stylesheets that have been imported into this one, but not
+    # resolving ':extends' inheritance.
+    #
+    # @param Symbol stylename, the stylename to search for.
+    # @param Hash so_far, the properties already found in stylesheets with
+    #                     lower precedence than this one.
+    # @param Hash seen, the Stylesheets that we've already visited, this is
+    #                   to avoid pathological cases where stylesheets
+    #                   have been imported recursively.
+    # @return Hash
+    def properties_for(stylename, so_far={}, seen={})
+      return so_far if seen[self]
+      seen[self] = true
+
+      imported.each do |name|
+        unless Teacup::Stylesheet.const_defined?(name)
+          raise "Teacup tried to import Stylesheet:#{name} into Stylesheet:#{self.name}, but it didn't exist"
+        end
+        Teacup::Stylesheet.const_get(name).properties_for(stylename, so_far, seen)
+      end
+
+      so_far.update(styles[stylename])
+    end
+
+    # The list of Stylesheet names that have been imported into this one.
+    #
+    # @return Array[Symbol]
+    def imported
+      @imported ||= []
+    end
+
+    # The actual contents of this stylesheet as a Hash from stylename to properties.
+    #
+    # @return Hash[Symbol, Hash]
+    def styles
+      @styles ||= Hash.new{ |h, k| h[k] = {} }
+    end
+  end
+end

data/lib/teacup/version.rb

@@ -0,0 +1,5 @@
+module Teacup
+
+  VERSION = '0.0.1'
+
+end

data/lib/teacup/view.rb

@@ -0,0 +1,123 @@
+module Teacup
+  # Teacup::View defines some utility functions for UIView that enable
+  # a lot of the magic for Teacup::Layout.
+  #
+  # Most users of teacup should be able to ignore the contents of this file
+  # for the most part.
+  module View
+    # The current stylename that is used to look up properties in the stylesheet.
+    attr_reader :stylename
+    
+    # The current stylesheet will be looked at when properties are needed.
+    attr_reader :stylesheet
+
+    # Alter the stylename of this view.
+    #
+    # This will cause new styles to be applied from the stylesheet.
+    #
+    # @param Symbol  stylename
+    def stylename=(stylename)
+      @stylename = stylename
+      style(stylesheet.query(stylename)) if stylesheet
+    end
+
+    # Alter the stylesheet of this view.
+    #
+    # This will cause new styles to be applied using the current stylename,
+    # and will recurse into subviews.
+    #
+    # If you would prefer that a given UIView object does not inherit the
+    # stylesheet from its parents, override the 'stylesheet' method to
+    # return the correct value at all times.
+    #
+    # @param Teacup::Stylesheet  stylesheet.
+    def stylesheet=(stylesheet)
+      @stylesheet = stylesheet
+      style(stylesheet.query(stylename)) if stylename && stylesheet
+      subviews.each{ |subview| subview.stylesheet = stylesheet }
+    end
+
+    # Animate a change to a new stylename.
+    #
+    # This is equivalent to wrapping a call to .stylename= inside
+    # UIView.beginAnimations.
+    #
+    # @param Symbol  the new stylename
+    # @param Options  the options for the animation (may include the
+    #                 duration and the curve)
+    #
+    def animate_to_stylename(stylename, options={})
+      return if self.stylename == stylename
+      UIView.beginAnimations(nil, context: nil)
+      # TODO: This should be in a style-sheet!
+      UIView.setAnimationDuration(options[:duration]) if options[:duration]
+      UIView.setAnimationCurve(options[:curve]) if options[:curve]
+      self.stylename = stylename
+      UIView.commitAnimations
+    end
+
+    # Apply style properties to this element.
+    #
+    # Takes a hash of properties such as may have been read from a stylesheet
+    # or passed as parameters to {Teacup::Layout#layout}, and applies them to
+    # the element.
+    #
+    # Does a little bit of magic (that may be split out as 'sugarcube') to
+    # make properties work as you'd expect.
+    #
+    # If you try and assign something in properties that is not supported,
+    # a warning message will be emitted.
+    #
+    # @param Hash  the properties to set.
+    def style(properties)
+      clean_properties! properties
+
+      properties.each do |key, value|
+        if key == :title && UIButton === self
+          setTitle(value, forState: UIControlStateNormal)
+        elsif respond_to?(:"#{key}=")
+          send(:"#{key}=", value)
+        elsif layer.respond_to?(:"#{key}=")
+          layer.send(:"#{key}=", value)
+        elsif key == :keyboardType
+          setKeyboardType(value)
+        else
+          $stderr.puts "Teacup WARN: Can't apply #{key} to #{inspect}"
+        end
+      end
+
+      #OUCH! Figure out why this is needed
+      if rand > 1
+        setCornerRadius(1.0) 
+        setFrame([[0,0],[0,0]])
+        setTransform(nil)
+        setMasksToBounds(0)
+        setShadowOffset(0)
+      end
+    end
+
+    # merge definitions for 'frame' into one.
+    #
+    # To support 'extends' more nicely it's convenient to split left, top, width
+    # and height out of frame. Unfortunately that means we have to write ugly
+    # code like this to reassemble them into what the user actually meant.
+    #
+    # WARNING: this method *mutates* its parameter.
+    #
+    # @param Hash
+    # @return Hash
+    def clean_properties!(properties)
+      return unless [:frame, :left, :top, :width, :height].any?(&properties.method(:key?))
+
+      frame = properties.delete(:frame) || self.frame
+
+      frame[0][0] = properties.delete(:left) || frame[0][0]
+      frame[0][1] = properties.delete(:top) || frame[0][1]
+      frame[1][0] = properties.delete(:width) || frame[1][0]
+      frame[1][1] = properties.delete(:height) || frame[1][1]
+
+      properties[:frame] = frame
+      properties
+    end
+  end
+end

data/proposals/other/README.md

@@ -0,0 +1,45 @@
+# Railsifiying mobile development
+
+** This is a rough idea, which may have lots of holes, please comment on it, post issues, or fork. ** 
+
+
+It's time we take control of iOS app development, because it's clunky, 
+slow, not obvious and because we love Ruby & Rails.
+
+We can't have "just" styling, it's not a full solution we need a framework now
+more then ever.
+
+With that said, I believe Rails provides a solid MVC. It can help hide or augment
+may of the typical problems with iOS development.
+
+
+Directory structure:
+
+    .teacup
+    |____app
+    | |____config
+    | | |____application.rb
+    | | |____boot.rb
+    | | |____initializers
+    | | | |____twitter.rb
+    | |____controllers
+    | | |____events_controller.rb
+    | | |____venues_controller.rb
+    | |____db
+    | | |____migrations
+    | | | |____20120514201043_create_events.rb
+    | | | |____20120514201044_add_price_to_events.rb
+    | | | |____20120514201045_create_venues.rb
+    | | |____README.md
+    | | |____schema.rb
+    | |____models
+    | | |____event.rb
+    | | |____venue.rb
+    | |____views
+    | | |____events
+    | | | |____edit.ipad.rb
+    | | | |____edit.iphone.rb
+    | | | |____show.ipad.rb
+    | | | |____show.iphone.rb
+    | | |____venues
+    |____README.md

data/proposals/other/app/config/application.rb

@@ -0,0 +1 @@
+# Idea: framework runtime, starts to load the application, load initializers, run migrations, etc

data/proposals/other/app/config/boot.rb

@@ -0,0 +1 @@
+# Idea: framework booting before application (if it's needed at all)

data/proposals/other/app/config/initializers/twitter.rb

@@ -0,0 +1,7 @@
+# 0. applicationDidFinishLaunching
+#   1. boot
+#   2. application
+#     3. initializers
+#       4. twitter configuration values loaded
+
+Twitter.setup("XXX", "YYY")

data/proposals/other/app/controllers/events_controller.rb

@@ -0,0 +1,28 @@
+class EventsController < Controller
+
+  # Idea: Need to think about this more, but in lue of generators, we could have 
+  # over-rideable defaults based on a responds_to/actions
+  # Idea: This would also configure what actions a controller can respond to / route to (do we need routes?)
+  responds_to :only => [:new, :create, :edit, :update, :destroy, :index, :show] # default options
+
+  def show(id)
+    @event = Event.find(id)
+    render :show
+  end
+
+  def edit(id)
+    @event = Event.find(id)
+  end
+
+  def update(id)
+    # Note: How would this conflict with the previously set @event, should something be passed? augment params?
+    @event = Event.find(id)
+    @event.update_attributes(
+      # 1. data from the current/old view?
+      # 2. autosave was false
+      :price => self.view.price
+    )
+    # render :edit # Idea: (self.view is loaded)
+  end
+
+end

data/proposals/other/app/controllers/venues_controller.rb

@@ -0,0 +1,4 @@
+class VenuesController < Controller
+  # Idea: We may want to force some kind of nesting in controller
+  belongs_to :event
+end

data/proposals/other/app/db/README.md

@@ -0,0 +1,16 @@
+# DB
+
+## CoreDataAdapter
+
+Rationale: CD is widely used in iOS projects and may be useful for simpler
+integration with UI.
+
+## SqlLiteAdapter
+
+This would be responsible for handling CoreData+Sqlite backend.
+
+## RemoteAdapter
+
+This would be responsible for handling remote data sources (initially just JSON).
+
+* A RemoteAdapter would be migration-less, APIs would need to be backwards compatible or be versioned, see endpoint in `models/event.rb`

data/proposals/other/app/db/migrations/20120514201043_create_events.rb

@@ -0,0 +1,9 @@
+class CreateEvents < Migration
+  def change
+    create_table(:events) do |t|
+      t.string :name
+      t.references :venue
+      t.timestamps
+    end
+  end
+end