astruct 2.11.0 → 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6990e238c22d0d907f210e88381630a930b20355
+  data.tar.gz: 028d8e80cc9b222c3383c511f514426a3d888eea
+SHA512:
+  metadata.gz: 64a93ec3749af729bd2d2bce28a225f22ec46e8ad415e4ba8004f69ad82dd81a0cf9b925a6040b76fb316a4bbf6e954542bce07540503d5ce6f9a29289e418fd
+  data.tar.gz: 5708d234e2e1cea7f644dc7be147ebc267d3c931aacc5a93b7a4386a2cb588ed1949eb4acfaf0d360871843dbe1a0eefba09f4ba6d258fd897be26639ff43e67

data/lib/astruct.rb

@@ -1,6 +1,5 @@
-require_relative 'astruct/module'
+require_relative "astruct/behavior"
 
-#
 # = astruct.rb: AltStruct implementation
 #
 # Author:: Kurtis Rainbolt-Greene
@@ -10,85 +9,11 @@ require_relative 'astruct/module'
 # create hash-like classes. Allowing you to create an object that can
 # dynamically accept accessors and behaves very much like a Hash.
 #
-
-#
-# An AltStruct is a data structure, similar to a Hash, that allows the
-# definition of arbitrary attributes with their accompanying values. This is
-# accomplished by using Ruby's metaprogramming to define methods on the class
-# itself.
-#
-
-#
-# == Examples:
-#
-#   require 'astruct'
-#
-#   class Profile < AltStruct
-#
-#   end
-#
-#   person = Profile.new name: "John Smith"
-#   person.age = 70
-#
-#   puts person.name     # => "John Smith"
-#   puts person.age      # => 70
-#   puts person.dump     # => { :name => "John Smith", :age => 70 }
-#
-
-#
-# An AltStruct employs a Hash internally to store the methods and values and
-# can even be initialized with one:
-#
-#   australia = AltStruct.new country: "Australia", population: 20_000_000
-#   puts australia.inspect # => <AltStruct country="Australia", population=20000000>
-#
-
-#
-# Hash keys with spaces or characters that would normally not be able to use for
-# method calls (e.g. ()[]*) will not be immediately available on the
-# AltStruct object as a method for retrieval or assignment, but can be still be
-# reached through the Object#send method.
-#
-#   measurements = AltStruct.new "length (in inches)" => 24
-#   measurements.send "length (in inches)"  # => 24
-#
-#   data_point = AltStruct.new :queued? => true
-#   data_point.queued?                       # => true
-#   data_point.send "queued?=", false
-#   data_point.queued?                       # => false
-#
-
-#
-# Removing the presence of a method requires the execution the delete_field
-# or delete (like a hash) method as setting the property value to +nil+
-# will not remove the method.
-#
-#   first_pet = AltStruct.new :name => 'Rowdy', :owner => 'John Smith'
-#   first_pet.owner = nil
-#   second_pet = AltStruct.new :name => 'Rowdy'
-#
-#   first_pet == second_pet   # -> false
-#
-#   first_pet.delete_field(:owner)
-#   first_pet == second_pet   # -> true
-#
-
-#
-# == Implementation:
-#
-# An AltStruct utilizes Ruby's method lookup structure to and find and define
-# the necessary methods for properties. This is accomplished through the method
-# method_missing and define_method.
-#
-
-#
-# This should be a consideration if there is a concern about the performance of
-# the objects that are created, as there is much more overhead in the setting
-# of these properties compared to using a Hash or a Struct.
-#
 class AltStruct
-  # We include all of the AltStruct::M Module in order to give AltStruct
+  # We include all of the AltStruct::Behavior Module in order to give AltStruct
   # the same behavior as OpenStruct. It's better, however, to simply
-  # include AltStruct::M into your own class.
-  include AltStruct::M
+  # include AltStruct::Behavior into your own class.
+  include AltStruct::Behavior
 end
+
+require_relative "astruct/version"

data/lib/astruct/behavior.rb

@@ -0,0 +1,251 @@
+require "set"
+
+class AltStruct
+  # An AltStruct is a data structure, similar to a Hash, that allows the
+  # definition of arbitrary attributes with their accompanying values. This is
+  # accomplished by using Ruby's meta-programming to define methods on the
+  # class itself.
+  #
+  #
+  # == Examples:
+  #
+  #     require 'astruct'
+  #
+  #     class Profile < AltStruct
+  #
+  #     end
+  #
+  #     person = Profile.new name: "John Smith"
+  #     person.age = 70
+  #
+  #     puts person.name     # => "John Smith"
+  #     puts person.age      # => 70
+  #     puts person.dump     # => { :name => "John Smith", :age => 70 }
+  #
+  # An AltStruct employs a Hash internally to store the methods and values and
+  # can even be initialized with one:
+  #
+  #     australia = AltStruct.new(
+  #       country: "Australia",
+  #       population: 20_000_000
+  #     )
+  #     puts australia.inspect
+  #       # => <AltStruct country="Australia", population=20000000>
+  #
+  # Hash keys with spaces or characters that would normally not be able to use
+  # for method calls (e.g. ()[]*) will not be immediately available on the
+  # AltStruct object as a method for retrieval or assignment, but can be still
+  # be reached through the `Object#send` method.
+  #
+  #     measurements = AltStruct.new "length (in inches)" => 24
+  #     measurements.send "length (in inches)"  # => 24
+  #
+  #     data_point = AltStruct.new :queued? => true
+  #     data_point.queued?                       # => true
+  #     data_point.send "queued?=", false
+  #     data_point.queued?                       # => false
+  #
+  # Removing the presence of a method requires the execution the delete_field
+  # or delete (like a hash) method as setting the property value to +nil+
+  # will not remove the method.
+  #
+  #     first_pet = AltStruct.new :name => 'Rowdy', :owner => 'John Smith'
+  #     first_pet.owner = nil
+  #     second_pet = AltStruct.new :name => 'Rowdy'
+  #
+  #     first_pet == second_pet   # -> false
+  #
+  #     first_pet.delete_field(:owner)
+  #     first_pet == second_pet   # -> true
+  #
+  #
+  # == Implementation:
+  #
+  # An AltStruct utilizes Ruby's method lookup structure to and find and define
+  # the necessary methods for properties. This is accomplished through the
+  # method `method_missing` and `define_singleton_method`.
+  #
+  # This should be a consideration if there is a concern about the performance
+  # of the objects that are created, as there is much more overhead in the
+  # setting of these properties compared to using a Hash or a Struct.
+  module Behavior
+    THREAD_KEY = :__as_ids__ # :nodoc:
+    NESTED_INSPECT = "...".freeze
+    INSPECT_DELIMITER = ", ".freeze
+    WRAP_PATTERN = /__/.freeze
+    UNSETABLE_PATTERN = /\@|\[|\]|\=\=|\~|\>|\<|\!\=/.freeze
+    SUFFIX_PATTERN = /(\?|\!)$/.freeze
+
+    # We want to give easy access to the table
+    attr_reader :table
+
+    # We want to automatically wrap important Ruby object methods
+    Object.instance_methods.each do |meth|
+      case meth
+
+      # Don't bother with already wrapped methods
+      when WRAP_PATTERN then next
+
+      # Skip methods that can't be set anyways
+      when UNSETABLE_PATTERN then next
+
+      # Get around Ruby's stupid method signature problems with ? and !
+      # suffixes
+      when SUFFIX_PATTERN then alias_method("__#{meth[0...-1]}__#{meth[-1]}".to_sym, meth)
+
+      # Finally, wrap regular methods
+      else alias_method("__#{meth}__".to_sym, meth)
+      end
+    end
+
+    # Create a new field for each of the key/value pairs passed.
+    # By default the resulting OpenStruct object will have no
+    # attributes. If no pairs are passed avoid any work.
+    #
+    #    require "astruct"
+    #    hash = { "country" => "Australia", :population => 20_000_000 }
+    #    data = AltStruct.new hash
+    #
+    #    p data # => <AltStruct country="Australia" population=20000000>
+    #
+    # If you happen to be inheriting then you can define your own
+    # `@table` ivar before the `super()` call. AltStruct will respect
+    # your `@table`.
+    #
+    def initialize(pairs = {})
+      @table ||= {}
+      __iterate_set_over__(pairs) unless pairs.empty?
+    end
+
+    # This is the `load()` method, which works like initialize in that it
+    # will create new fields for each pair passed. It mimics the behavior of a
+    # Hash#merge.
+    def __load__(pairs)
+      __iterate_set_over__(pairs) unless pairs.empty?
+    end
+    alias_method :marshal_load, :__load__
+    alias_method :load, :__load__
+    alias_method :merge, :__load__
+
+    # This is the `load!()` method, which works like Hash#merge!
+    # See: `AltStruct#load()`
+    def __load__!(pairs)
+      __iterate_set_over__(pairs, true)
+    end
+    alias_method :marshal_load!, :__load__!
+    alias_method :load!, :__load__!
+    alias_method :merge!, :__load__!
+
+    # The `dump()` takes the table and out puts in it's natural hash
+    # format. In addition you can pass along a specific set of keys to
+    # dump.
+    def __dump__(*keys)
+      if keys.empty? then @table else __dump_specific__(keys) end
+    end
+    alias_method :marshal_dump, :__dump__
+    alias_method :dump, :__dump__
+    alias_method :to_hash, :__dump__
+
+    def __inspect__
+      "#<#{__class__}#{__dump_inspect__}>"
+    end
+    alias_method :inspect, :__inspect__
+    alias_method :to_sym, :__inspect__
+
+    # The `delete()` method removes a key/value pair on the @table
+    # and on the singleton class. It also mimics the Hash#delete method.
+    def __delete__(key)
+      __singleton_class__.send(:remove_method, key)
+      __singleton_class__.send(:remove_method, "#{key}=")
+      @table.delete(key.to_sym)
+    end
+    alias_method :delete_field, :__delete__
+    alias_method :delete, :__delete__
+
+    # The `method_missing()` method catches all non-tabled method calls.
+    # The AltStruct object will return two specific errors depending on
+    # the call.
+    def method_missing(method, *arguments)
+      name = method.to_s
+      if name.split("").last == "=" && arguments.size == 1
+        __define_field__(name.chomp!("="), arguments.first)
+      else
+        if name.split.last != "="
+          super
+        else arguments.size > 1
+          raise(ArgumentError,"wrong number of arguments (#{arguments.size} for 1)")
+        end
+      end
+    end
+
+    def ==(other)
+      if other.respond_to?(:table)
+        table == other.table
+      else
+        false
+      end
+    end
+
+    def freeze
+      super
+      @table.freeze
+    end
+    alias_method :__freeze__, :freeze
+    alias_method :__frozen?, :frozen?
+
+    private
+
+    def __dump_inspect__
+      Thread.current[THREAD_KEY] ||= Set.new
+
+      if __dump__.any? then " #{__dump_subinspect__}" else "" end.tap do
+        __thread_ids__.delete(__object_id__)
+      end
+    end
+
+    def __dump_subinspect__
+      if __thread_ids__.add?(__object_id__)
+        __dump_string__.join(INSPECT_DELIMITER)
+      else
+        NESTED_INSPECT
+      end
+    end
+
+    def __thread_ids__
+      Thread.current[THREAD_KEY]
+    end
+
+    def __define_field__(key, value)
+      __define_accessor__(key)
+      __set_table__(key, value)
+    end
+
+    def __define_accessor__(key)
+      singleton_class.send(:define_method, key) { @table[key] }
+      singleton_class.send(:define_method, "#{key}=") { |v| @table[key] = v }
+    end
+
+    def __set_table__(key, value)
+      @table.merge!(key => value) unless key.nil?
+    end
+
+    def __dump_specific__(keys)
+      @table.keep_if { |key| keys.include?(key.to_sym) }
+    end
+
+    def __dump_string__
+      __dump__.map { |key, value| "#{key}=#{value.inspect}" }
+    end
+
+    def __iterate_set_over__(pairs, force = false)
+      pairs.each do |key, value|
+        if force && respond_to?(key)
+          __set_table__(key, value)
+        else
+          __define_accessor__(key)
+          __set_table__(key, value)
+        end
+      end
+    end
+  end
+end

data/lib/astruct/version.rb

@@ -1,4 +1,3 @@
 class AltStruct
-  # This is the AltStruct version
-  VERSION = "2.11.0"
+  VERSION = "3.0.0"
 end

data/spec/lib/astruct/behavior_spec.rb

@@ -0,0 +1,10 @@
+require "spec_helper"
+
+describe AltStruct::Behavior do
+  let(:pairs) { { a: 1, b: 2, c: 3} }
+  let(:astruct) { ExampleAltStruct.new(pairs) }
+
+  it "reponds to each key as a method" do
+    expect(astruct).to have_attributes(pairs)
+  end
+end

data/spec/lib/astruct/version_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+RSpec.describe AltStruct::VERSION do
+  it "should be a string" do
+    expect(AltStruct::VERSION).to be_kind_of(String)
+  end
+end

data/spec/lib/astruct_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+RSpec.describe AltStruct do
+  let(:astruct) { described_class.new }
+
+  it "should behave like AltStruct::Behavior" do
+    expect(astruct).to respond_to(*AltStruct::Behavior.instance_methods)
+  end
+
+  it "should have aliases for standard methods" do
+    expect(astruct).to respond_to(:__object_id__)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require "codeclimate-test-reporter"
+require "pry"
+require "rspec"
+require "astruct"
+
+RSpec.configure do |let|
+  let.before("suite") do
+    CodeClimate::TestReporter.start
+  end
+
+  # Exit the spec after the first failure
+  let.fail_fast = true
+
+  # Only run a specific file, using the ENV variable
+  # Example: FILE=spec/blankgem/version_spec.rb bundle exec rake spec
+  let.pattern = ENV["FILE"]
+
+  # Show the slowest examples in the suite
+  let.profile_examples = true
+
+  # Colorize the output
+  let.color = true
+
+  # Output as a document string
+  let.default_formatter = "doc"
+end
+
+class ExampleAltStruct
+  include AltStruct::Behavior
+end

data/test/lib/{astruct_test.rb → astruct/test_behavior.rb}

@@ -1,10 +1,10 @@
-require 'helper'
-require 'minitest/autorun'
+require "test_helper"
+require "minitest/autorun"
 
 class TestAltStruct < MiniTest::Unit::TestCase
   def setup
     @empty = AltStruct.new
-    @example = AltStruct.new name: "Kurtis", age: 24
+    @example = AltStruct.new(name: "Kurtis", age: 24)
   end
 
   def test_equality_with_two_empty_astructs
@@ -39,9 +39,9 @@ class TestAltStruct < MiniTest::Unit::TestCase
   end
 
   def test_inspect_with_sub_struct_duplicate
-    @empty.struct2 = AltStruct.new
-    @empty.struct2.struct3 = @empty
-    expected = '#<AltStruct struct2=#<AltStruct struct3=#<AltStruct ...>>>'
+    @empty.substruct = AltStruct.new
+    @empty.substruct.subsubstruct = @empty
+    expected = "#<AltStruct substruct=#<AltStruct subsubstruct=#<AltStruct ...>>>"
     actual = @empty.inspect
     assert_equal expected, actual
   end
@@ -50,7 +50,7 @@ class TestAltStruct < MiniTest::Unit::TestCase
     @example.friends = AltStruct.new name: "Jason", age: 24
     @example.friends.friends = AltStruct.new name: "John", age: 15
     @example.friends.friends.friends = AltStruct.new name: "Ally", age: 32
-    expected = '#<AltStruct name="Kurtis", age=24, friends=#<AltStruct name="Jason", age=24, friends=#<AltStruct name="John", age=15, friends=#<AltStruct name="Ally", age=32>>>>'
+    expected = "#<AltStruct name=\"Kurtis\", age=24, friends=#<AltStruct name=\"Jason\", age=24, friends=#<AltStruct name=\"John\", age=15, friends=#<AltStruct name=\"Ally\", age=32>>>>"
     actual = @example.inspect
     assert_equal expected, actual
   end
@@ -58,14 +58,14 @@ class TestAltStruct < MiniTest::Unit::TestCase
   def test_inspect_with_twice_inspected_struct
     @example.inspect
     @example.inspect
-    expected = '#<AltStruct name="Kurtis", age=24>'
+    expected = "#<AltStruct name=\"Kurtis\", age=24>"
     actual = @example.inspect
     assert_equal expected, actual
   end
 
   def test_inspect_with_empty_sub_struct
     @empty.struct2 = AltStruct.new
-    expected = '#<AltStruct struct2=#<AltStruct>>'
+    expected = "#<AltStruct struct2=#<AltStruct>>"
     actual = @empty.inspect
     assert_equal expected, actual
   end
@@ -91,7 +91,7 @@ class TestAltStruct < MiniTest::Unit::TestCase
   #   @example.freeze
   #   def @example.frozen?; nil end
   #   @example.freeze
-  #   message = '[ruby-core:22559]'
+  #   message = "[ruby-core:22559]"
   #   assert_raises(RuntimeError, message) { @example.name = "Jazzy" }
   #   # assert_raises(TypeError, message) { @example.name = "Jazzy" }
   # end
@@ -105,13 +105,13 @@ class TestAltStruct < MiniTest::Unit::TestCase
   end
 
   def test_delete_field_removes_getter_method
-    bug = '[ruby-core:33010]'
+    bug = "[ruby-core:33010]"
     @example.delete_field :name
     refute_respond_to @example, :name, bug
   end
 
   def test_delete_field_removes_setter_method
-    bug = '[ruby-core:33010]'
+    bug = "[ruby-core:33010]"
     @example.delete_field :name
     refute_respond_to @example, :name=, bug
   end
@@ -130,7 +130,7 @@ class TestAltStruct < MiniTest::Unit::TestCase
   end
 
   def test_method_missing_handles_square_bracket_equals
-    assert_raises(ArgumentError) { @empty[:foo] = :bar }
+    assert_raises(NoMethodError) { @empty[:foo] = :bar }
   end
 
   def test_method_missing_handles_square_brackets