structx 0.1.0

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+vendor
+html

data/.simplecov

@@ -0,0 +1,8 @@
+require 'coveralls'
+Coveralls.wear!
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.command_name 'bacon'
+SimpleCov.start {add_filter 'test'}

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - "1.9.2"
+  - "1.9.3"
+  - "2.0.0"
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-19mode
+script: rake test

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in forwardablex.gemspec
+gemspec
+
+gem 'simplecov', :require => false, :group => :test
+gem 'coveralls', :require => false, :group => :test
+gem 'json', '~> 1.7.7'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Keita Yamaguchi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,61 @@
+# StructX
+
+StructX is an extension of Ruby standard Struct. The diffences are that 1) the constructor handles hash table as key-value pairs, 2) you can specify members as statements, and 3) you can set default values of member. StructX's API is compatible with Struct.
+
+[![Gem Version](https://badge.fury.io/rb/structx.png)](http://badge.fury.io/rb/structx) [![Build Status](https://travis-ci.org/keita/structx.png?branch=master)](https://travis-ci.org/keita/structx) [![Coverage Status](https://coveralls.io/repos/keita/structx/badge.png?branch=master)](https://coveralls.io/r/keita/structx) [![Code Climate](https://codeclimate.com/github/keita/structx.png)](https://codeclimate.com/github/keita/structx)
+
+## Installation
+
+    $ gem install structx
+
+## Usage
+
+### Constructor with hash table
+
+```ruby
+StructX.new(:x, :y, :z).new(x: 1, y: 2, z: 3) #=> #<struct x=1, y=10, z=100>
+```
+
+### Member sentences
+
+```ruby
+class A < StructX
+  member :x
+  member :y
+  member :z
+end
+A.new(1, 2, 3) #=> #<struct A x=1, y=2, z=3>
+```
+
+### Default values
+
+```ruby
+class B < StructX
+  member :x
+  member :y, default: 10
+  member :z, default: 100
+end
+B.new(1) # => #<struct B x=1, y=10, z=100>
+```
+
+## Documentation
+
+- [API Documentation](http://rubydoc.info/gems/structx)
+
+## License
+
+StructX is free software distributed under MIT license.
+The following files are copied from ruby's test case, so you should keep its lisense.
+
+- test/ruby/1.9/test_struct.rb
+- test/ruby/1.9/envutil.rb
+- test/ruby/2.0/test_struct.rb
+- test/ruby/2.0/envutil.rb
+
+## 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/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+
+desc 'Test specs'
+task 'test' do
+  sh "test/run.sh"
+end
+
+desc 'Generate API document'
+task 'html' do
+  sh "bundle exec yard doc -o html --hide-void-return --no-api"
+end
+
+desc 'Show undocumented function list'
+task 'html:undoc' do
+  sh "bundle exec yard stats --list-undoc --no-api --compact"
+end
+
+task :default => :test

data/lib/structx.rb

@@ -0,0 +1,169 @@
+require "forwardablex"
+require "structx/version"
+
+# StructX is an extension of Ruby standard Struct. The diffences are that 1) the
+# constructor handles hash table as key-value pairs, 2) you can specify members
+# as statements, and 3) you can set default values of member. StructX's API is
+# compatible with Struct.
+#
+# @example Constructor with hash table
+#   StructX.new(:x, :y, :z).new(x: 1, y: 2, z: 3) #=> #<struct x=1, y=10, z=100>
+# @example Member sentences
+#   class A < StructX
+#     member :x
+#     member :y
+#     member :z
+#   end
+#   A.new(1, 2, 3) #=> #<struct A x=1, y=2, z=3>
+# @example Default values
+#   class B < StructX
+#     member :x
+#     member :y, default: 10
+#     member :z, default: 100
+#   end
+#   B.new(1) # => #<struct B x=1, y=10, z=100>
+class StructX
+  include Enumerable
+
+  class << self
+    alias :orig_new :new
+    private :orig_new
+
+    # Same as Struct[].
+    alias :[] :new
+
+    # Create a instance or sublcass. If this class has members, create an
+    # instance. The case handles hash table as key-value pairs. If this class
+    # has no members, create a subclass.
+    #
+    # @param args [Array or Hash]
+    #   Same as Struct if args is Array. Consider args as key-value pairs if it is Hash.
+    def new(*args)
+      # create an instance
+      return orig_new(*args) if @member
+
+      # create subclass
+      Class.new(StructX).tap do |subclass|
+        # class name
+        if args.first.kind_of?(String)
+          const_set(args.first, subclass)
+          args = args.drop(1)
+        end
+
+        # set members
+        args.each {|m| subclass.member(*m)}
+
+        # this is according to MRI, why yield?
+        yield if block_given?
+      end
+    end
+
+    # Same as Struct#members.
+    def members
+      (@member ||= {}).keys
+    end
+
+    # Add member into structure.
+    #
+    # @param name [Symbol]
+    #   member name
+    # @param data [Hash]
+    #   member options
+    def member(name, data={})
+      (@member ||= {})[name] = Hash.new.merge(data)
+
+      # define member's value reader
+      define_method(name) do
+        @value[name]
+      end
+
+      # define member's value writer
+      define_method("%s=" % name) do |val|
+        @value[name] = val
+      end
+    end
+
+    # Return default values.
+    #
+    # @return [Hash{Symbol=>Object}]
+    #   default values
+    def default_values
+      @member.inject({}) do |tbl, (key, val)|
+        tbl.tap {|x| x[key] = val[:default] if val.has_key?(:default)}
+      end
+    end
+
+    private
+
+    def inherited(subclass)
+      @member.each {|key, data| subclass.member(key, data)} if @member
+    end
+  end
+
+  # almost methods are forwarded to value table
+  forward :class, :members
+  forward :@value, :each, :each_pair
+  forward! :@value, :values, :length, :size, :hash
+  forward! lambda{|x| @value.values}, :each, :values_at
+
+  alias :to_a :values
+
+  # See Struct.new.
+  def initialize(*values)
+    if values.first.kind_of?(Hash) and values.size == 1
+      @value = __build__(values.first)
+    else
+      raise ArgumentError.new("struct size differs #{values}  #{members} ") if values.size > members.size
+      @value = __build__(members.zip(values))
+    end
+  end
+
+  # Same as Struct#[].
+  def [](idx)
+    case idx
+    when Integer
+      size > idx && -size <= idx ? values[idx] : (raise IndexError.new(idx))
+    when Symbol, String
+      members.include?(idx.to_sym) ? @value[idx.to_sym] : (raise NameError.new(idx.to_s))
+    end
+  end
+
+  # Same as Struct#[]=.
+  def []=(idx, val)
+    case idx
+    when Integer
+      size > idx && -size <= idx ? @value[members[idx]] = val : (raise IndexError.new(idx))
+    when Symbol, String
+      members.include?(idx.to_sym) ? @value[idx.to_sym] = val : (raise NameError.new(idx.to_s))
+    end
+  end
+
+  # Same as Struct#inspect.
+  def inspect
+    name = self.class.inspect[0] == "#" ? "" : " " + self.class.inspect
+    values = @value.map do |key, val|
+      k = (key.to_s[0] == "@" ? ":" : "") + key.to_s
+      v = self == val ? "#<struct %s:...>" % val : val.inspect
+      "%s=%s" % [k, v]
+    end
+    "#<struct%s %s>" % [name, values.join(", ")]
+  end
+
+  # Same as Struct#eql?.
+  def eql?(other)
+    self.class == other.class and @value == other.to_h
+  end
+  alias :"==" :eql?
+
+  # Same as Struct#to_h. This method is available in Ruby 1.9 too.
+  def to_h
+    @value
+  end
+
+  private
+
+  def __build__(data)
+    tbl = data.inject({}) {|tbl, (m, val)| tbl.tap {|x| x[m] = val if val}}
+    self.class.default_values.merge(tbl)
+  end
+end

data/lib/structx/version.rb

@@ -0,0 +1,4 @@
+class StructX
+  # version of StructX
+  VERSION = "0.1.0"
+end

data/structx.gemspec

@@ -0,0 +1,29 @@
+# -*- ruby -*-
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'structx/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "structx"
+  spec.version       = StructX::VERSION
+  spec.authors       = ["Keita Yamaguchi"]
+  spec.email         = ["keita.yamaguchi@gmail.com"]
+  spec.description   = "sturctx is a Ruby library that extends standard Struct"
+  spec.summary       = "sturctx is a Ruby library that extends standard Struct"
+  spec.homepage      = "https://github.com/keita/structx"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "forwardablex"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "bacon"
+  spec.add_development_dependency "yard"
+  spec.add_development_dependency "ruby-version"
+end

data/test/compatibility-test.rb

@@ -0,0 +1,32 @@
+require "structx"
+require "ruby-version"
+
+def patch(code)
+  ## Struct -> StructX
+  code = code.gsub("Struct", "StructX")
+  ## clear require_relative
+  code = code.gsub(/^require_relative.*$/, "")
+  ## modify error message for test_struct_subclass
+  # StructX can handle security error but the message is different
+  code = code.gsub("Insecure: can't modify \#\{st}::S", "Insecure: can't modify hash")
+end
+
+def load_test(target)
+  require_relative "../test/ruby/#{target}/envutil"
+  path = File.join(File.dirname(__FILE__), "ruby", target, "test_struct.rb")
+  eval patch(File.read(path))
+end
+
+if Ruby::Engine::NAME == "ruby"
+  if Ruby::Version >= "1.9" and Ruby::Version < "2.0"
+    load_test("1.9")
+  end
+
+  if Ruby::Version >= "2.0"
+    load_test("2.0")
+  end
+else
+  puts "We cannot run compatibility test with jruby and rbx."
+  puts "Related to Struct, these VMs are not compatible with MRI."
+end
+

data/test/ruby/1.9/envutil.rb

@@ -0,0 +1,212 @@
+require "open3"
+require "timeout"
+
+module EnvUtil
+  def rubybin
+    unless ENV["RUBYOPT"]
+
+    end
+    if ruby = ENV["RUBY"]
+      return ruby
+    end
+    ruby = "ruby"
+    rubyexe = ruby+".exe"
+    3.times do
+      if File.exist? ruby and File.executable? ruby and !File.directory? ruby
+        return File.expand_path(ruby)
+      end
+      if File.exist? rubyexe and File.executable? rubyexe
+        return File.expand_path(rubyexe)
+      end
+      ruby = File.join("..", ruby)
+    end
+    if defined?(RbConfig.ruby)
+      RbConfig.ruby
+    else
+      "ruby"
+    end
+  end
+  module_function :rubybin
+
+  LANG_ENVS = %w"LANG LC_ALL LC_CTYPE"
+
+  def invoke_ruby(args, stdin_data="", capture_stdout=false, capture_stderr=false, opt={})
+    in_c, in_p = IO.pipe
+    out_p, out_c = IO.pipe if capture_stdout
+    err_p, err_c = IO.pipe if capture_stderr && capture_stderr != :merge_to_stdout
+    opt = opt.dup
+    opt[:in] = in_c
+    opt[:out] = out_c if capture_stdout
+    opt[:err] = capture_stderr == :merge_to_stdout ? out_c : err_c if capture_stderr
+    if enc = opt.delete(:encoding)
+      out_p.set_encoding(enc) if out_p
+      err_p.set_encoding(enc) if err_p
+    end
+    timeout = opt.delete(:timeout) || 10
+    c = "C"
+    child_env = {}
+    LANG_ENVS.each {|lc| child_env[lc] = c}
+    if Array === args and Hash === args.first
+      child_env.update(args.shift)
+    end
+    args = [args] if args.kind_of?(String)
+    pid = spawn(child_env, EnvUtil.rubybin, *args, opt)
+    in_c.close
+    out_c.close if capture_stdout
+    err_c.close if capture_stderr && capture_stderr != :merge_to_stdout
+    if block_given?
+      return yield in_p, out_p, err_p, pid
+    else
+      th_stdout = Thread.new { out_p.read } if capture_stdout
+      th_stderr = Thread.new { err_p.read } if capture_stderr && capture_stderr != :merge_to_stdout
+      in_p.write stdin_data.to_str
+      in_p.close
+      if (!th_stdout || th_stdout.join(timeout)) && (!th_stderr || th_stderr.join(timeout))
+        stdout = th_stdout.value if capture_stdout
+        stderr = th_stderr.value if capture_stderr && capture_stderr != :merge_to_stdout
+      else
+        raise Timeout::Error
+      end
+      out_p.close if capture_stdout
+      err_p.close if capture_stderr && capture_stderr != :merge_to_stdout
+      Process.wait pid
+      status = $?
+      return stdout, stderr, status
+    end
+  ensure
+    [in_c, in_p, out_c, out_p, err_c, err_p].each do |io|
+      io.close if io && !io.closed?
+    end
+    [th_stdout, th_stderr].each do |th|
+      (th.kill; th.join) if th
+    end
+  end
+  module_function :invoke_ruby
+
+  alias rubyexec invoke_ruby
+  class << self
+    alias rubyexec invoke_ruby
+  end
+
+  def verbose_warning
+    class << (stderr = "")
+      alias write <<
+    end
+    stderr, $stderr, verbose, $VERBOSE = $stderr, stderr, $VERBOSE, true
+    yield stderr
+  ensure
+    stderr, $stderr, $VERBOSE = $stderr, stderr, verbose
+    return stderr
+  end
+  module_function :verbose_warning
+
+  def suppress_warning
+    verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = verbose
+  end
+  module_function :suppress_warning
+
+  def under_gc_stress
+    stress, GC.stress = GC.stress, true
+    yield
+  ensure
+    GC.stress = stress
+  end
+  module_function :under_gc_stress
+end
+
+module Test
+  module Unit
+    module Assertions
+      public
+      def assert_normal_exit(testsrc, message = '', opt = {})
+        if opt.include?(:child_env)
+          opt = opt.dup
+          child_env = [opt.delete(:child_env)] || []
+        else
+          child_env = []
+        end
+        out, _, status = EnvUtil.invoke_ruby(child_env + %W'-W0', testsrc, true, :merge_to_stdout, opt)
+        pid = status.pid
+        faildesc = proc do
+          signo = status.termsig
+          signame = Signal.list.invert[signo]
+          sigdesc = "signal #{signo}"
+          if signame
+            sigdesc = "SIG#{signame} (#{sigdesc})"
+          end
+          if status.coredump?
+            sigdesc << " (core dumped)"
+          end
+          full_message = ''
+          if !message.empty?
+            full_message << message << "\n"
+          end
+          full_message << "pid #{pid} killed by #{sigdesc}"
+          if !out.empty?
+            out << "\n" if /\n\z/ !~ out
+            full_message << "\n#{out.gsub(/^/, '| ')}"
+          end
+          full_message
+        end
+        assert !status.signaled?, faildesc
+      end
+
+      def assert_in_out_err(args, test_stdin = "", test_stdout = [], test_stderr = [], message = nil, opt={})
+        stdout, stderr, status = EnvUtil.invoke_ruby(args, test_stdin, true, true, opt)
+        if block_given?
+          yield(stdout.lines.map {|l| l.chomp }, stderr.lines.map {|l| l.chomp })
+        else
+          if test_stdout.is_a?(Regexp)
+            assert_match(test_stdout, stdout, message)
+          else
+            assert_equal(test_stdout, stdout.lines.map {|l| l.chomp }, message)
+          end
+          if test_stderr.is_a?(Regexp)
+            assert_match(test_stderr, stderr, message)
+          else
+            assert_equal(test_stderr, stderr.lines.map {|l| l.chomp }, message)
+          end
+          status
+        end
+      end
+
+      def assert_ruby_status(args, test_stdin="", message=nil, opt={})
+        _, _, status = EnvUtil.invoke_ruby(args, test_stdin, false, false, opt)
+        m = message ? "#{message} (#{status.inspect})" : "ruby exit status is not success: #{status.inspect}"
+        assert(status.success?, m)
+      end
+
+      def assert_warn(msg)
+        stderr = EnvUtil.verbose_warning { yield }
+        assert(msg === stderr, "warning message #{stderr.inspect} is expected to match #{msg.inspect}")
+      end
+
+
+      def assert_is_minus_zero(f)
+        assert(1.0/f == -Float::INFINITY, "#{f} is not -0.0")
+      end
+    end
+  end
+end
+
+begin
+  require 'rbconfig'
+rescue LoadError
+else
+  module RbConfig
+    @ruby = EnvUtil.rubybin
+    class << self
+      undef ruby if method_defined?(:ruby)
+      attr_reader :ruby
+    end
+    dir = File.dirname(ruby)
+    name = File.basename(ruby, CONFIG['EXEEXT'])
+    CONFIG['bindir'] = dir
+    CONFIG['ruby_install_name'] = name
+    CONFIG['RUBY_INSTALL_NAME'] = name
+    Gem::ConfigMap[:bindir] = dir if defined?(Gem::ConfigMap)
+  end
+end