opt_struct 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8ffdb6352a7c6f0ac1b8ace9d92f9618b6f15b6d
+  data.tar.gz: d87218eb3c56609fab3185facd228771ae2ac2bd
+SHA512:
+  metadata.gz: b310d805c7e04e852828893c04591620ff55e922747b25a5551e1dc57f3bf832b401c2ad0f2a8a83bdaf39150582389a18449e9d2f9d7a08ec24bca4d05ac78d
+  data.tar.gz: 630df79a1c2ba0c2899324b69f14e2e90f72a0d366487bba94c388a63966214efa5e0fe324e72a6bacf01674a3b1fdeeffe5de264209f49de1d1bbcbedd8bb1d

data/README.md

@@ -0,0 +1,83 @@
+# The Opt Struct
+
+A struct around a hash
+
+## Example 1
+
+Can work mostly like a regular struct, while accepting options
+
+```ruby
+MyClass = OptStruct.new(:foo, :bar)
+
+MyClass.new
+# => argument error
+
+MyClass.new "foo", "bar"
+# => #<MyClass>
+
+i = MyClass.new "foo", "bar", yin: "yang"
+i.options
+# => {yin: "yang"}
+i.fetch(:yin)
+# => "yang"
+```
+
+## Example 2
+
+Passing a hash promotes the keys (`:foo` below) to an `option` giving it getter/setter methods on the class. The value becomes the default. This is equivalent and can be combined with using the `option` macro.
+
+If an option is required it needs to be called out as such using `required`.
+
+```ruby
+class MyClass < OptStruct.new(foo: "bar")
+  required :yin # equivalent to: `option :yin, required: true`
+  option :bar, default: "foo"
+end
+
+MyClass.new
+# => missing keyword argument :yin
+
+i = MyClass.new yin: "yang"
+# => #<MyClass>
+i.foo
+# => "bar"
+i.bar
+# => "foo"
+i.foo = "foo"
+i.options
+# => {foo: "foo", bar: "foo", yin: "yang"}
+```
+
+## Example 3
+
+Works as a plain old mixin as well.
+
+```ruby
+class MyClass
+  include OptStruct
+  required :foo
+end
+
+MyClass.new
+# => missing keyword argument :foo
+
+MyClass.new(foo: "bar").foo
+# => "bar"
+```
+
+## Example 4
+
+Options passed to `new` can be passed to `build` when used in module form.
+
+```ruby
+class MyClass
+  include OptStruct.build(:foo, bar: nil)
+end
+
+MyClass.new
+# => argument error
+
+i = MyClass.new("something", bar: "foo")
+[i.foo, i.bar]
+# => ["something", "foo"]
+```

data/lib/opt_struct/class_methods.rb

@@ -0,0 +1,63 @@
+module OptStruct
+  module ClassMethods
+    def inherited(subclass)
+      instance_variables.each do |v|
+        subclass.send(:instance_variable_set, v, instance_variable_get(v).dup)
+      end
+    end
+
+    def required_keys
+      @required_keys ||= []
+    end
+
+    def required(*keys)
+      required_keys.concat keys
+      option_accessor *keys
+    end
+
+    def option_reader(*keys)
+      keys.each do |key|
+        define_method(key) { options[key] }
+      end
+    end
+
+    def option_writer(*keys)
+      keys.each do |key|
+        define_method("#{key}=") { |value| options[key] = value }
+      end
+    end
+
+    def option_accessor(*keys)
+      option_reader *keys
+      option_writer *keys
+    end
+
+    def option(key, default = nil, **options)
+      default = options[:default] if options.key?(:default)
+      defaults[key] = default
+      required_keys << key if options[:required]
+      option_accessor key
+    end
+
+    def options(*keys, **keys_defaults)
+      option_accessor *keys if keys.any?
+      if keys_defaults.any?
+        defaults.merge!(keys_defaults)
+        option_accessor *(keys_defaults.keys - expected_arguments)
+      end
+    end
+
+    def defaults
+      @defaults ||= {}
+    end
+
+    def expect_arguments(*arguments)
+      @expected_arguments = arguments
+      attr_accessor *arguments
+    end
+
+    def expected_arguments
+      @expected_arguments || []
+    end
+  end
+end

data/lib/opt_struct/instance_methods.rb

@@ -0,0 +1,50 @@
+module OptStruct
+  module InstanceMethods
+    def initialize(*values, **options)
+      @options = self.class.defaults.merge(options)
+      steal_arguments_from_options
+      assign_arguments(values)
+      check_arguments(values)
+      check_required_keys
+    end
+
+    def fetch(*a, &b)
+      options.fetch(*a, &b)
+    end
+
+    private
+
+    def steal_arguments_from_options
+      expected_arguments.each do |arg|
+        send("#{arg}=", options.delete(arg)) if options.key?(arg)
+      end
+    end
+
+    def assign_arguments(values)
+      values.each_with_index do |value, i|
+        send("#{expected_arguments[i]}=", value)
+      end
+    end
+
+    def check_arguments(args)
+      expected = expected_arguments.count
+      actual = expected_arguments.count do |arg|
+        instance_variable_defined?("@#{arg}")
+      end
+      unless actual == expected
+        raise ArgumentError, "only #{actual} of #{expected} required arguments present"
+      end
+    end
+
+    def check_required_keys
+      missing = self.class.required_keys.select { |key| !options.key?(key) }
+      if missing.any?
+        raise ArgumentError, "missing required keywords: #{missing.inspect}"
+      end
+    end
+
+    def expected_arguments
+      self.class.expected_arguments
+    end
+  end
+end

data/lib/opt_struct.rb

@@ -0,0 +1,50 @@
+require "opt_struct/class_methods"
+require "opt_struct/instance_methods"
+
+module OptStruct
+  def self.inject_struct(target_klass, &more_block)
+    target_klass.instance_exec do
+      extend ClassMethods
+      attr_reader :options
+      include InstanceMethods
+    end
+    target_klass.instance_exec(&more_block) if block_given?
+    target_klass
+  end
+
+  def self.included(klass)
+    inject_struct(klass)
+  end
+
+  def self.new(*args, **defaults)
+    check_for_invalid_args(args)
+    args.map!(&:to_sym)
+    inject_struct(Class.new) do
+      expect_arguments *args
+      options defaults
+    end
+  end
+
+  def self.build(*args, **defaults)
+    check_for_invalid_args(args)
+    args.map!(&:to_sym)
+    Module.new do
+      @arguments = args
+      @defaults = defaults
+
+      def self.included(klass)
+        arguments, defaults = @arguments, @defaults
+        OptStruct.inject_struct(klass) do
+          expect_arguments *arguments
+          options defaults
+        end
+      end
+    end
+  end
+
+  private
+
+  def self.check_for_invalid_args(args)
+
+  end
+end

data/opt_struct.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |spec|
+  spec.name          = "opt_struct"
+  spec.version       = "0.2.0"
+  spec.authors       = ["Carl Zulauf"]
+  spec.email         = ["carl@linkleaf.com"]
+
+  spec.summary       = %q{The Option Struct}
+  spec.description   = %q{Struct with support for keyword params and mixin support}
+  spec.homepage      = "https://github.com/carlzulauf/opt_struct"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split("\n").grep(/^lib/)
+  spec.files        += %w(README.md opt_struct.gemspec)
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: opt_struct
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Carl Zulauf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Struct with support for keyword params and mixin support
+email:
+- carl@linkleaf.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/opt_struct.rb
+- lib/opt_struct/class_methods.rb
+- lib/opt_struct/instance_methods.rb
+- opt_struct.gemspec
+homepage: https://github.com/carlzulauf/opt_struct
+licenses:
+- MIT
+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.6.11
+signing_key: 
+specification_version: 4
+summary: The Option Struct
+test_files: []