yoga_layout 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 26a638d33929146562ee6e51da0f722c69e6396b
+  data.tar.gz: 599d1368d1dbc2a113ecbd12492fdcb0bac63c10
+SHA512:
+  metadata.gz: ce2a19b0ec43b55d2c541352c6e61f1f1db096b60b106f35f477e08697d1f1d4c294f2a9b2ff49ce86bd067d870e4ffe240885afde25a48fa60a909cb9531e82
+  data.tar.gz: 25f13f5bcf4d48277ecfe898795a54f208ef5ef8a6708c2b018b1f484a11c3e243ef41f084334cde58503b55763871c98463cb4e3bde250ef71c724dd3c3818a

data/.gitignore

@@ -0,0 +1,22 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+# rspec failure tracking
+.rspec_status
+
+# we don't care about the Yoga source files right now; they should be copied in
+# during gem build from the repo root
+ext/yoga_layout/*.c
+ext/yoga_layout/*.h

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.0.0
+before_install: gem install bundler -v 1.15.2

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in yoga_layout.gemspec
+gemspec

data/README.md

@@ -0,0 +1,35 @@
+# YogaLayout
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/yoga_layout`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'yoga_layout'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install yoga_layout
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/justjake/yoga_layout.

data/Rakefile

@@ -0,0 +1,176 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rake/extensiontask"
+
+task :build => :compile
+
+Rake::ExtensionTask.new("yoga_layout") do |ext|
+  ext.lib_dir = "lib/yoga_layout"
+end
+
+task :copy_src do
+  sh 'cp ../yoga/* ext/yoga_layout'
+end
+
+# Parses Yoga.h into ruby function information
+class YogaHeaderParser
+  # partial regexes for the parts of a macro call
+  MACRO_NAME = 'YG_[A-Z_]+'
+  ARGUMENT = '[*\w ]+'
+  COMMA = ',\s?'
+
+  # a regex to parse a single macro call
+  MACRO_REGEX = /
+  ^                           # start of line
+  (?<macro>#{MACRO_NAME})          # eg, 'YG_NODE_STYLE_PROPERTY'
+  \(                          # '('
+  (?<type>#{ARGUMENT})        # the "type" argument, eg 'YGValue' or 'void *'
+  #{COMMA}                    #
+  (?<name>#{ARGUMENT})        # the name of the property, eg 'MinWidth'
+  (?:                         # optional group, because not all calls have a paramName
+   #{COMMA}
+   (?<paramName>#{ARGUMENT})  # the paramName, eg 'minWidth'
+  )?                          # close the optional group, and mark it optional
+  \)                          # ')'
+  ;?                          # usually, but not always, we need a ; at the end
+  $                           # end of line
+  /x
+
+  def initialize(header_source)
+    @header = header_source
+    @functions = []
+  end
+
+  def call
+    matches.each do |match|
+      handle_match(match)
+    end
+    @functions
+  end
+
+  # crazy ruby nonsense to get all the matches of the regex on the string
+  def matches
+    @matches ||= @header.to_enum(:scan, MACRO_REGEX).map { Regexp.last_match }
+  end
+
+  def handle_match(match)
+    case match['macro']
+    when 'YG_NODE_PROPERTY'
+      yg_node_property(match)
+    when 'YG_NODE_STYLE_PROPERTY'
+      yg_node_style_property(match)
+    when 'YG_NODE_STYLE_PROPERTY_UNIT'
+      yg_node_style_property_unit(match)
+    when 'YG_NODE_STYLE_PROPERTY_UNIT_AUTO'
+      yg_node_style_property_unit_auto(match)
+    when 'YG_NODE_STYLE_EDGE_PROPERTY'
+      yg_node_style_edge_property(match)
+    when 'YG_NODE_STYLE_EDGE_PROPERTY_UNIT'
+      yg_node_style_edge_property_unit(match)
+    when 'YG_NODE_STYLE_EDGE_PROPERTY_UNIT_AUTO'
+      yg_node_style_edge_property_unit_auto(match)
+    when 'YG_NODE_LAYOUT_PROPERTY'
+      yg_node_layout_property(match)
+    when 'YG_NODE_LAYOUT_EDGE_PROPERTY'
+      yg_node_layout_edge_property(match)
+    else
+      raise "Unparsable: #{match}"
+    end
+  end
+
+  def declare(fn_info)
+    name, args, result = fn_info
+    name = name.to_sym
+    args = args.map { |t| normalize_type(t) }
+    result = normalize_type(result)
+    @functions << [name, args, result]
+  end
+
+  def normalize_type(type)
+    case type
+    when 'void *'
+      :pointer
+    when Symbol
+      type
+    when String
+      type.to_sym
+    else
+      raise "cannot normalize type #{type.inpect}"
+    end
+  end
+
+  def yg_node_property(match)
+   declare ["YGNodeSet#{match['name']}", [:YGNodeRef, match['type']], :void]
+   declare ["YGNodeGet#{match['name']}", [:YGNodeRef], match['type']]
+  end
+
+  def yg_node_style_property(match)
+    declare ["YGNodeStyleSet#{match['name']}", [:YGNodeRef, match['type']], :void]
+    declare ["YGNodeStyleGet#{match['name']}", [:YGNodeRef], match['type']]
+  end
+
+  def yg_node_style_property_unit(match)
+    declare ["YGNodeStyleSet#{match['name']}", [:YGNodeRef, :float], :void]
+    declare ["YGNodeStyleSet#{match['name']}Percent", [:YGNodeRef, :float], :void]
+    declare ["YGNodeStyleGet#{match['name']}", [:YGNodeRef], match['type']]
+  end
+
+  def yg_node_style_property_unit_auto(match)
+    puts "unit_auto: #{match.inspect}"
+    yg_node_style_property_unit(match)
+    declare ["YGNodeStyleSet#{match['name']}Auto", [:YGNodeRef], :void]
+  end
+
+  def yg_node_style_edge_property(match)
+    declare ["YGNodeStyleSet#{match['name']}", [:YGNodeRef, :YGEdge, match['type']], :void]
+    declare ["YGNodeStyleGet#{match['name']}", [:YGNodeRef, :YGEdge], match['type']]
+  end
+
+  def yg_node_style_edge_property_unit(match)
+    declare ["YGNodeStyleSet#{match['name']}", [:YGNodeRef, :YGEdge, :float], :void]
+    declare ["YGNodeStyleSet#{match['name']}Percent", [:YGNodeRef, :YGEdge, :float], :void]
+    # According to YGMacros.h, the return type here should be
+    # pointerOf(match['type']) on Windows ARM.
+    # This is Ruby, we don't care.
+    declare ["YGNodeStyleGet#{match['name']}", [:YGNodeRef, :YGEdge], match['type']]
+  end
+
+  def yg_node_style_edge_property_unit_auto(match)
+    declare ["YGNodeStyleSet#{match['name']}Auto", [:YGNodeRef, :YGEdge], :void]
+  end
+
+  def yg_node_layout_property(match)
+    declare ["YGNodeLayoutGet#{match['name']}", [:YGNodeRef], match['type']]
+  end
+
+  def yg_node_layout_edge_property(match)
+    declare ["YGNodeLayoutGet#{match['name']}", [:YGNodeRef, :YGEdge], match['type']]
+  end
+end
+
+desc 'Auto-generate lib/yoga_layout/native/functions.rb from Yoga.h by parsing macros'
+task :ygnode_properties do
+  header = File.read('../yoga/Yoga.h')
+
+  parser = YogaHeaderParser.new(header)
+  functions = parser.call
+
+  File.open('lib/yoga_layout/bindings/ygnode_properties.rb', 'w') do |file|
+    file.puts('# Auto-generated by Rake from Yoga.h')
+    file.puts('# Do not edit by hand')
+    file.puts("module YogaLayout")
+    file.puts("  module Bindings")
+    functions.each do |fn_info|
+      attrs = fn_info.inspect[1..-2]
+      puts "writing function #{attrs}"
+      file.puts("    remember_function #{attrs}")
+    end
+    file.puts("  end")
+    file.puts("end")
+  end
+end
+
+task :default => [:copy_src, :ygnode_properties, :clobber, :compile, :spec]

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "yoga_layout"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "pry"
+Pry.start

data/bin/demo

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require 'pry'
+require "yoga_layout"
+require "drawille"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+def node_enum(node)
+  Enumerator.new do |y|
+    queue = []
+    queue << node
+
+    while queue.size > 0
+      node = queue.pop
+      y << node
+      node.get_child_count.times do |i|
+        child = node.get_child(i)
+        queue << child
+      end
+    end
+  end
+end
+
+def rect(brush, top, left, width, height)
+  top_left = [left, top]
+  top_right = [left + width, top]
+  bottom_right = [left + width, top + height]
+  bottom_left = [left, top + height]
+
+  brush.line(from: top_left, to: top_right)
+  brush.line(from: top_right, to: bottom_right)
+  brush.line(from: bottom_right, to: bottom_left)
+  brush.line(from: bottom_left, to: top_left)
+end
+
+def show_layout(root)
+  root.calculate_layout
+  canvas = Drawille::Canvas.new
+  brush = Drawille::Brush.new(canvas)
+  node_enum(root).each do |node|
+    rect(
+      brush,
+      node.layout[:top],
+      node.layout[:left],
+      node.layout[:width],
+      node.layout[:height],
+    )
+  end
+  puts canvas.frame
+end
+
+class Draw
+  def initialize
+    @canvas = Drawille::Canvas.new
+    @brush = Drawille::Brush.new(@canvas)
+  end
+
+  def draw_node(node)
+  end
+
+  def show
+    puts @canvas.frame
+  end
+end
+
+layout = YogaLayout::Node[
+  width: 500,
+  height: 100,
+  flex_direction: :row,
+  padding: 20,
+  children: [
+    YogaLayout::Node[
+      width: 80,
+      margin_end: 20,
+    ],
+    YogaLayout::Node[
+      height: 25,
+      align_self: :center,
+      flex_grow: 1,
+    ]
+  ],
+]
+
+binding.pry
+
+show_layout(layout)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/yoga_layout/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile("yoga_layout/yoga_layout")

data/lib/yoga_layout.rb

@@ -0,0 +1,33 @@
+# YogaLayout provides a thin FFI-based wrapper around the core Yoga library.
+#
+# Yoga is a cross-platform layout engine enabling maximum collaboration within
+# your team by implementing an API familiar to many designers and opening it up
+# to developers across different platforms.
+#
+# @see https://facebook.github.io/yoga
+module YogaLayout
+  # Root error class for the YogaLayout module
+  class Error < ::StandardError; end
+
+  # Turn a CamelCase string into a snake_case string.
+  #
+  # @api private
+  def self.underscore(string)
+    string.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      downcase
+  end
+
+  require 'yoga_layout/version'
+  require 'yoga_layout/bindings'
+  require 'yoga_layout/node'
+  require 'yoga_layout/config'
+
+  def self.undefined
+    ::Float::NAN
+  end
+
+  def self.float_is_undefined?(float)
+    ::YogaLayout::Bindings.YGFloatIsUndefined(float)
+  end
+end

data/lib/yoga_layout/bindings.rb

@@ -0,0 +1,39 @@
+require 'ffi'
+
+# Our C extension, which loads the Yoga C code.
+require "yoga_layout/yoga_layout"
+
+module YogaLayout
+  # Native is the libffi wrapper around Yoga.
+  # It does not implement anything novel like memory management or nice ruby types.
+  # It's just a compatibility layer.
+  module Bindings
+    extend ::FFI::Library
+    # ref https://github.com/ffi/ffi/wiki/Loading-Libraries#in-memory-libraries
+    ffi_lib ::FFI::USE_THIS_PROCESS_AS_LIBRARY
+
+    def self.functions
+      @functions ||= {}
+    end
+
+    # Wrapper around FFI::Library.attach_function that also remembers the function
+    # name and arguments for later static analysis
+    def self.remember_function(*args)
+      result = attach_function(*args)
+      functions[args.first] = args
+      result
+    end
+
+    # Auto-genrated by ../../enums.py
+    require 'yoga_layout/bindings/enums'
+
+    # Written by hand
+    require 'yoga_layout/bindings/typedefs'
+    require 'yoga_layout/bindings/ygnode'
+    require 'yoga_layout/bindings/ygconfig'
+    require 'yoga_layout/bindings/misc'
+
+    # Auto-generated by `rake ygnode_properties`
+    require 'yoga_layout/bindings/ygnode_properties'
+  end
+end