goldensections 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 03ee7fb6c5e7b0f1038092abf4f87bae26a1de31
+  data.tar.gz: 471000325fbfb0981a0e0ad9f0f176b87bf8b363
+SHA512:
+  metadata.gz: ba7ad2dce54eddb9c454860af09cfc1733d43744a2cad6d44f9993ce1b0298a3633884b34c824c480503101305e32612c95cdb514a745d69c0cf87c0a57d86a2
+  data.tar.gz: 23b459f3866a5de0f3d601aa04eb371ad133f393711d1076b2e752d54c1e3b5e69ac2b1ce00cb3e0987e54fa8a7dfd07863633fe70c169f3611173cc110cdedd

data/README.md

@@ -0,0 +1,87 @@
+Golden Sections
+https://github.com/austinseraphin/goldensections
+
+Welcome to Golden Sections, a RubyMotion gem for creating views based
+on the golden mean. I wrote this gem because using the golden mean
+looks naturally beautiful. Instead of guessing or picking round
+numbers, why not use something more appealing? Give your app the Midas
+touch with Golden Sections!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'goldensections'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install goldensections
+
+This gem depends on Geomotion.
+
+## Usage
+
+Firstly, the gem adds a method to the Numeric class called
+golden_section(exponent) the parameter represents the exponent of the
+golden mean to use, defaulting to 1.
+
+It then adds golden_section class and instance methods to CGPoint,
+CGSize, and CGRect. The class methods i.e. CGRect.golden_section take
+a hash of options. The options depend on the class, but should include
+enough information to create an object. For CGPoint this means
+specifying either :x or :y. For CGSize this means specifying either
+:width or :height. CGRect can take any combination of these options,
+usually :x, :y, and either :width or :height. The methods then fill in
+the missing attributes. They also take a :exponent option. For
+example:
+
+point=CGPoint.golden_section(x: 100) => CGPoint(100.0,
+61.8033905029297) size=CGSize.golden_section(width: 100) =>
+CGSize(100.0, 61.8033905029297) rect=CGRect.golden_section(x: 0, y: 0,
+width: 100) => CGRect([0.0, 0.0], [100.0, 61.8033905029297])
+
+The fifth exponent of the golden ratio comes out to 11.08. Instead of
+making a label that takes up a tenth of the screen, you could try
+this:
+
+CGRect.golden_section(x: 0, y: 0, width: 100, exponent: 5) =>
+CGRect([0.0, 0.0], [100.0, 9.01699829101562])
+
+The instance methods take an existing object and return a new object
+based on it. They take a direction, either :width or :height, and
+optionally an exponent.
+
+point.golden_section(:x) => CGPoint(61.8033905029297,
+61.8033905029297) size.golden_section(:width) =>
+CGSize(61.8033905029297, 61.8033905029297) rect.golden_section(:width)
+=> CGRect([0.0, 0.0], [61.8033905029297, 61.8033905029297])
+
+Finally, you can use the golden_split method to split a CGRect into
+two. It has two parameters. First, specify the direction to split the
+rectangle, either :width or :height. Imagine folding a piece of paper
+along its width or length. The second parameter controls which section
+should have the greater area, either :first or :last. It returns an
+array containing the two CGRect objects.
+
+rect=CGRect.new([0,0],[100,100]) => CGRect([0.0, 0.0], [100.0, 100.0])
+rect.golden_split(:width) => [CGRect([0.0, 0.0], [61.8033905029297,
+100.0]), CGRect([61.8033905029297, 0.  0], [38.1965942382812, 100.0])]
+rect.golden_split(:height) => [CGRect([0.0, 0.0], [100.0,
+61.8033905029297]), CGRect([0.0, 61.803390502929 7], [100.0,
+38.1965942382812])] rect.golden_split(:height, :last) => [CGRect([0.0,
+0.0], [100.0, 38.1966094970703]), CGRect([0.0, 38.196609497070 3],
+[100.0, 61.8034210205078])]
+
+And that should just about do it. Have fun making beautiful apps.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/goldensections.rb

@@ -0,0 +1,9 @@
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+require 'geomotion'
+
+lib_dir_path = File.dirname(File.expand_path(__FILE__))
+Motion::Project::App.setup do |app|
+  app.files.unshift(Dir.glob(File.join(lib_dir_path, "project/**/*.rb")))
+end

data/lib/project/cg_point.rb

@@ -0,0 +1,27 @@
+class CGPoint
+
+# Given an x or y coordinate, returns a point with the other coordinate set to
+# the golden section
+# @param options [hash] either the :x or :y coordinate, and optionally exponent
+# @return [CGPoint] the new point
+def self.golden_section(options)
+  Golden_Sections.handler(Golden_Sections::CGPoint_relations, options, &Golden_Sections::CGPoint_proc)
+end
+
+# Returns a CGPoint with one or both coordinates as a golden section
+# @param direction [Symbol] Which coordinate to modify - :x, :y, or :both, the default.
+# @param exp [Integer] The exponent of the golden mean, defaults to 1
+# @return [CGPoint] The new CGPoint
+def golden_section(direction=:both, exp=1)
+if direction==:both
+CGPoint.new(self.x.golden_section(exp), self.y.golden_section(exp))
+elsif direction==:x
+CGPoint.new(self.x.golden_section(exp), self.y)
+elsif direction==:y
+CGPoint.new(self.x, self.y.golden_section(exp))
+else
+  raise "CGPoint: unknown direction #{direction}"
+end
+end
+
+end

data/lib/project/cg_rect.rb

@@ -0,0 +1,59 @@
+class CGRect
+
+# Creates a CGRect with the proportions of the golden section
+# @param options [Hash] The combination of size and height parameters, and optionally exponent.
+ # :x, :y, or both
+ # :width, :height, or both
+ # The method fills in the missing attributes.
+# @return [CGRect] the new object
+def self.golden_section(options)
+Golden_Sections::handler(Golden_Sections::CGRect_relations, options, &Golden_Sections::CGRect_proc)
+end
+
+ # Creates a new CGRect changing the width, height, or both in the proportion of
+ #the golden section
+# direction [Symbol] :width, :height, or :both, the dfeault
+# @param exp [Integer] the exponent of the golden mean, deafults to 1
+# @return [CGRect] the new object
+def golden_section(direction=:both,  exp=1)
+rect=self.dup
+fixed=false
+if direction==:width||direction==:both
+rect.width=rect.width.golden_section(exp)
+fixed=true
+end
+if direction==:height||direction==:both
+rect.height=rect.height.golden_section(exp)
+fixed=true
+end
+  raise "CGRect#golden_section: unknown direction: #{direction}" unless fixed
+rect
+end
+
+# Splits a rectangle into two, with the proportion of the golden section
+# @param direction [Symbol] :width or :height, this controls how to split the rectangle. Imagine folding a piece of paper along its width or length.
+# @param greater [Symbol] controls which rectangle has the greater area, :first or :last. Defaults to :first.
+# @return [Array] an array of the two CGRect objects
+def golden_split(direction, greater=:first)
+  raise "Golden_Section#golden_split: unknown direction #{direction}" unless [:width, :height].member?(direction)
+  raise "Golden_Section.golden_split: Unknown greater section #{greater}" unless [:first, :last].member?(greater)
+if greater==:first
+exp=1
+else
+exp=2
+end
+rect1=self.golden_section(direction,exp)
+if greater==:first
+exp=1
+else
+exp=-1
+end
+if direction==:width
+rect2=rect1.beside.width(rect1.width.golden_section(exp))
+else
+rect2=rect1.below.height(rect1.height.golden_section(exp))
+end
+[rect1,rect2]
+end
+
+end

data/lib/project/cg_size.rb

@@ -0,0 +1,28 @@
+class CGSize
+
+# Given a width or height, returns a new CGSize object with the other
+ # set to the golden section
+# @param options [Hash] the width or height, and optionally exponent
+# @return [CGSize] the new CGSize object
+def self.golden_section(options)
+Golden_Sections::handler(Golden_Sections::CGSize_relations, options, &Golden_Sections::CGSize_proc)
+end
+
+# Returns a new CGSize object with the width, height, or both modified
+ #to conform to the golden section
+# @param direction [Symbol] :width, :height, or :both, the default
+# @param exp [Integer] the exponent of the golden mean, defaults to 1
+# @return [CGSize] the new object
+def golden_section(direction=:both, exp=1)
+if direction==:both
+CGSize.new(self.width.golden_section(exp), self.height.golden_section(exp))
+elsif direction==:width
+CGSize.new(self.width.golden_section(exp), self.height)
+elsif direction==:height
+CGSize.new(self.width, self.height.golden_section(exp))
+else
+  raise "CGSize#golden_section: unknown direction #{direction}"
+end
+end
+
+end

data/lib/project/constants.rb

@@ -0,0 +1,18 @@
+class Golden_Sections
+
+# The version of golden-sections
+Version='0.0.2'
+
+# The all-important golden mean
+Golden_Mean=1.6180339
+
+# Relations of CGPoint attributes
+  CGPoint_relations = {:x => :y}
+
+# Relations of CGSize attributes
+  CGSize_relations = {:width => :height}
+
+# Relations of CGRect attributes
+  CGRect_relations = {:x => :y, :width => :height}
+
+end

data/lib/project/goldensections.rb

@@ -0,0 +1,4 @@
+class Golden_Sections
+
+end
+

data/lib/project/handler.rb

@@ -0,0 +1,30 @@
+# Golden_Sections handler for common methods
+
+class Golden_Sections
+
+# A common handler for golden_section methods
+# @param relations [Hash] the set of relations to use
+# @param options [Hash] the options passed by the user
+# @param init [Proc] the initialization method to call
+def self.handler(relations, options, &init)
+options[:exponent]||=1
+  relations.each do |relation1, relation2|
+if options[relation1]&&!options[relation2]
+options[relation2]=options[relation1].golden_section(options[:exponent])
+elsif options[relation2]&&!options[relation1]
+options[relation1]=options[relation2].golden_section(options[:exponent])
+end
+end
+init.call(options)
+end
+
+# CGPoint initializer
+CGPoint_proc=lambda {|options| CGPoint.new(options[:x], options[:y])} 
+
+# CGSize initializer
+CGSize_proc=lambda {|options| CGSize.new(options[:width], options[:height])} 
+
+# CGRect initializer
+CGRect_proc = lambda {|options| CGRect.new([options[:x], options[:y]], [options[:width], options[:height]])}
+
+end

data/lib/project/math.rb

@@ -0,0 +1,11 @@
+# Golden Sections mathematical methods
+
+class Numeric
+
+# Returns the golden section of a number
+# @param exponent [Numeric] the exponent of the golden mean, defaults to 1
+def golden_section(exponent=1)
+self/(Golden_Sections::Golden_Mean**exponent)
+end
+
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: goldensections
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- Austin Seraphin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: geomotion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Easily make views based on the golden section
+email:
+- austin@austinseraphin.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/goldensections.rb
+- lib/project/cg_point.rb
+- lib/project/cg_rect.rb
+- lib/project/cg_size.rb
+- lib/project/constants.rb
+- lib/project/goldensections.rb
+- lib/project/handler.rb
+- lib/project/math.rb
+homepage: https://github.com/austinseraphin/goldensections
+licenses:
+- GPL
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Welcome to Golden Sections, a RubyMotion gem for creating views based on
+  the golden mean. I wrote this gem because using the golden mean looks naturally
+  beautiful. Instead of guessing or picking round numbers, why not use something more
+  appealing? Give your app the Midas
+test_files: []