maimai_net 0.0.1

data/lib/maimai_net/module_ext.rb

@@ -0,0 +1,437 @@
+require 'fiddle'
+
+module MaimaiNet
+  # collection of modules with extended functionality
+  #
+  # @note some of these modules may be moved out into a separate gem in a later date.
+  module ModuleExt
+    # enables capability of having class_method block definition for a module.
+    # @note it's not valid to use this outside this file.
+    module HaveClassMethods
+      # defines an internal module to be inherited into
+      # calling class's eugenclass.
+      # @return [void]
+      def class_method(&block)
+        ref = self
+        @_class_module ||= Module.new
+        @_class_module.instance_eval <<~EOF
+          def to_s
+            "#{ref}::ClassMethod"
+          end
+          alias inspect to_s
+        EOF
+        @_class_module.class_exec(&block)
+      end
+
+      # defines a hook to automatically extend target class
+      # with internal module from #class_method
+      # @param cls [Class] calling class
+      # @return [void]
+      def included(cls)
+        super
+
+        base = self
+        cls.instance_exec do
+          next unless Class === cls
+          next unless base.instance_variable_defined?(:@_class_module)
+          next unless Module === base.instance_variable_get(:@_class_module)
+          ext_class = base.instance_variable_get(:@_class_module)
+          # the use of singleton_class.include and extend are the same.
+          extend ext_class
+          # singleton_class.send(:include, ext_class)
+        end
+      end
+    end
+
+    # extends inspect function into customizable inspect output
+    module ExtendedInspect
+      extend HaveClassMethods
+
+      # @return [String] simplified human-readable output
+      def inspect
+        head = '%s:%0#*x' % [
+          self.class.name,
+          0.size.succ << 1,
+          Fiddle.dlwrap(self),
+        ]
+
+        vars = []
+        all_true             = !self.class.instance_variable_defined?(:@_inspect_permit)
+        if all_true then
+          permit_variables   = []
+          permit_expressions = []
+          exclude_variables  = []
+        else
+          all_true          |= !self.class.instance_variable_get(:@_inspect_permit)
+
+          permit_variables   = self.class.instance_variable_get(:@_inspect_permit_variables)
+          permit_expressions = self.class.instance_variable_get(:@_inspect_permit_expressions)
+          exclude_variables  = self.class.instance_variable_get(:@_inspect_permit_variable_bans)
+
+          all_true          |= [
+            permit_variables,
+            exclude_variables,
+            permit_expressions,
+          ].all?(&:empty?)
+        end
+
+        self.instance_variables.each do |k|
+          name = k.to_s[1..-1].to_sym
+          value = self.instance_variable_get(k)
+
+          next if exclude_variables.include? name
+
+          is_permit = all_true
+
+          unless is_permit
+            is_permit |= permit_variables.include?(name)
+            is_permit |= permit_expressions.any? do |expr| !!expr.call(value) end
+          end
+
+          vars << sprintf(
+            '@%s=%s',
+            name,
+            is_permit ? value.inspect : value.class.name,
+          )
+        end
+
+        '#<%s>' % [
+          [head, *vars].join(' '),
+        ]
+      end
+
+      class_method do
+        # inherits inspect permit from superclass
+        def inherited(cls)
+          super
+
+          %i(
+            inspect_permit
+            inspect_permit_variables
+            inspect_permit_variable_bans
+            inspect_permit_expressions
+          ).each do |k|
+            name = :"@_#{k}"
+            source = instance_variable_get(name)
+            value = source.dup rescue source
+
+            cls.instance_variable_set(name, value)
+          end
+        end
+
+        private
+
+        # @return [void]
+        def inspect_permit_reset!
+          @_inspect_permit = false
+          @_inspect_permit_variables = []
+          @_inspect_permit_variable_bans = []
+          @_inspect_permit_expressions = []
+        end
+
+        # @param names [Array<String, Symbol>] list of variable name to permit by default
+        # @return [void]
+        def inspect_permit_variables(*names)
+          fail ArgumentError, 'empty list given' if names.empty?
+          fail ArgumentError, 'non-String given' if names.any? do |name| !(String === name || Symbol === name) end
+
+          @_inspect_permit ||= true
+          @_inspect_permit_variables.concat names.map(&:to_s).map(&:to_sym)
+          nil
+        end
+
+        # @param names [Array<String, Symbol>] list of variable name to exclude from inspection
+        # @return [void]
+        def inspect_permit_variable_exclude(*names)
+          fail ArgumentError, 'empty list given' if names.empty?
+          fail ArgumentError, 'non-String given' if names.any? do |name| !(String === name || Symbol === name) end
+
+          @_inspect_permit ||= true
+          @_inspect_permit_variable_bans.concat names.map(&:to_s).map(&:to_sym)
+          nil
+        end
+
+        # @param block [#call] a predicate method or block that accepts
+        #   single argument of instance variable value to permit for.
+        # @return [void]
+        def inspect_permit_expression(&block)
+          fail ArgumentError, 'no block given' unless block_given?
+
+          @_inspect_permit ||= true
+          @_inspect_permit_expressions.push block
+          nil
+        end
+      end
+
+      # initializes inspect permit variables upon inclusion
+      # @note will not apply to modules.
+      # @return [void]
+      def self.included(cls)
+        super
+
+        cls.instance_exec do
+          inspect_permit_reset!
+        end if Class === cls
+      end
+    end
+
+    module AddInternalMutex
+      extend HaveClassMethods
+
+      class_method do
+        private
+        def lock(key, meth, &block)
+          @_method_mutex ||= {}
+          @_method_mutex[key] ||= {}
+          can_lock = !@_method_mutex[key].fetch(meth, nil)&.locked?
+          return unless can_lock
+
+          mutex = @_method_mutex[key][meth] = Mutex.new
+          mutex.lock
+          yield
+        ensure
+          if can_lock then
+            mutex.unlock if mutex.locked?
+            @_method_mutex[key].delete(meth) if can_lock
+          end
+        end
+      end
+    end
+
+    # automatically private any initialize-based methods
+    module AutoInitialize
+      extend HaveClassMethods
+
+      class_method do
+        # automatically private any initialize-based methods
+        # @return [void]
+        def method_added(meth)
+          private meth if /^initialize_/.match? meth
+          super
+        end
+      end
+    end
+
+    # allows registering methods into cacheable results.
+    module MethodCache
+      extend HaveClassMethods
+
+      # Hooks method that specified through cache_method with internal cache wrapper.
+      # @see #cache_method
+      def singleton_method_added(meth)
+        singleton_class.class_exec do
+          is_locked = false
+          mutex = @_method_mutex.to_h.dig(:cache_method, meth)
+          is_locked = mutex.locked? if mutex && mutex.locked?
+
+          if @_cache_methods&.include?(meth) && !is_locked then
+            alias_method :"raw_#{meth}", meth
+            _cache_method(meth)
+          end
+        end
+
+        super
+      end
+
+      class_method do
+        # only copies methods to hook definition
+        # @return [void]
+        def inherited(cls)
+          super
+
+          %i(
+            cache_methods
+            cache_results
+          ).each do |k|
+            name = :"@_#{k}"
+            source = instance_variable_get(name)
+            value = source.dup rescue source
+
+            cls.instance_variable_set(name, value)
+          end
+
+          cls.instance_variable_get(:@_cache_results)&.tap do |result|
+            source = instance_variable_get(:@_cache_results)
+            result.clear
+            result.default_proc = source.default_proc
+          end
+        end
+
+        # Hooks method that specified through cache_method with internal cache wrapper.
+        # @see #cache_method
+        def method_added(meth)
+          mutex = @_method_mutex.to_h.dig(:cache_method, meth)
+          is_locked = mutex&.locked?
+
+          if @_cache_methods&.include?(meth) && !is_locked then
+            alias_method :"raw_#{meth}", meth
+            _cache_method(meth)
+          end
+
+          super
+        end
+
+        private
+
+        # This method works in a few ways.
+        # If a block is given, this acts like define_method but automatically hooked on-the-fly.
+        # Else if the method is previously defined, it will wrap the method into cached method.
+        # Otherwise, just add the method to the internal list to hook upon definition.
+        #
+        # @note does not support methods with any arity yet.
+        # @param meth [String, Symbol] method name to cache for
+        # @return [String, Symbol] meth parameter returned.
+        def cache_method(meth, &block)
+          if block_given? then
+            define_method :"raw_#{meth}", &block
+            _cache_method(meth)
+          else
+            @_cache_methods ||= []
+            @_cache_methods << meth
+
+            if instance_methods.include? meth then
+              if private_instance_methods.include? :"raw_#{meth}" then
+                warn "%s: ignoring private method aliasing for '#{meth}'." % [caller_locations(1, 1).first] if $VERBOSE
+              else
+                alias_method :"raw_#{meth}", meth
+              end
+              _cache_method(meth)
+            else
+              # fail NotImplementedError, "cannot lazy-hook '#{meth}' method for singleton class, please define using 'cache_method #{meth.inspect} do ... end' block instead." if singleton_class?
+            end
+          end
+
+          meth
+        end
+
+        # @!api private
+        # decorator to redefine method to support cached result.
+        # @param meth [String, Symbol] method name to redefine
+        # @return [void]
+        # @see #cache_method
+        def _cache_method(meth)
+          first, *stack = caller_locations(0)
+          stack_fit = ->(count, *labels){
+            last = stack[count.pred]
+            first.absolute_path == last.absolute_path &&
+              labels.map(&:to_s).include?(last.label)
+          }
+
+          fail 'cannot call this method from outside' unless
+            stack_fit.call(1, :cache_method, :method_added) ||
+            stack_fit.call(3, :singleton_method_added)
+
+          private :"raw_#{meth}"
+          cache = @_cache_results
+          invoke = ->(meth, *args, **kwargs, &block) {
+            kwargs.empty? ?
+              meth.call(*args, &block) :
+              meth.call(*args, **kwargs, &block)
+          }
+          map_parameters = ->(meth, *args, **kwargs, &block) {
+            parameters  = meth.parameters.map(&:first)
+            positionals = {front: [], rest: args, back: []}
+            pos_rest_at = parameters.index(:rest)
+            if pos_rest_at.nil? then
+              positionals[:front] = args
+              positionals[:rest]  = []
+            else
+              positionals[:front] = args.slice! (...pos_rest_at)
+              positionals[:back]  = args.slice! ((pos_rest_at + 1)..)
+            end
+
+            keyword_names = meth.parameters.select do |t, k| %i(keyreq key).include? k end
+            keywords, options = keyword_names.select do |t, k| %i(keyreq key keyrest).include? k end
+                                  .partition do |t, k| %i(keyreq key).include?(k) end
+                                  .map do |li|
+                                    kwargs.values_at(*li.map(&:last))
+                                  end
+
+            have_block = parameters.include? :block
+            raw_parameters = [
+              *positionals[:front],
+              positionals[:rest],
+              *positionals[:back],
+
+              keywords, options,
+            ]
+            raw_parameters << block if have_block
+
+            raw_parameters
+          }
+
+          use_param_hash = true
+
+          lock :cache_method, meth do
+            define_method meth do |*args, **kwargs, &block|
+              m = method(:"raw_#{meth}")
+              if use_param_hash and not(args.empty? and kwargs.empty?) then
+                param_hash = map_parameters.call(m, *args, **kwargs, &block).hash
+                return cache[meth][__id__][param_hash] if cache.key?(meth) && cache[meth].key?(__id__) && cache[meth][__id__].key?(param_hash)
+                cache[meth][__id__] = {} unless cache[meth].key? __id__
+                cache[meth][__id__][param_hash] = invoke.call(m, *args, **kwargs, &block)
+              else
+                return cache[meth][__id__] if cache.key?(meth) && cache[meth].key?(__id__)
+                cache[meth][__id__] = invoke.call(m, *args, **kwargs, &block)
+              end
+            end
+          end
+        end
+      end
+
+      # initializes internal data for method caching
+      # @return [void]
+      def self.included(cls)
+        cls.class_exec do
+          include AddInternalMutex
+        end
+
+        super
+
+        cls.class_exec do
+          if singleton_class? then
+            # define_method :singleton_method_added, method(:method_added).unbind
+            singleton_class.undef_method :method_added
+          else
+            undef_method :singleton_method_added
+          end
+        end
+
+        cls.instance_exec do
+          proc_key_to_id = ->(h, k){
+            case k
+            when Integer
+              h[k]
+            when Float, NilClass, TrueClass, FalseClass
+              fail KeyError, "invalid key"
+            else
+              h[k.object_id]
+            end
+          }
+
+          @_cache_methods ||= []
+          @_cache_results ||= Hash.new do |h, k|
+            next h[k.to_sym] if h.key?(k.to_sym)
+            h[k.to_sym] = Hash.new &proc_key_to_id
+          end
+        end
+      end
+    end
+
+    %i(ExtendedInspect AutoInitialize).tap do |keys|
+      const_list = keys.map do |k| const_get k end
+      keys.each do |k| remove_const k end
+
+      [
+        %i(append_features include),
+        %i(prepend_features prepend),
+      ].each do |(source_meth, internal_meth)|
+        define_singleton_method source_meth do |cls|
+          cls.__send__ internal_meth, *const_list
+        end
+      end
+    end
+
+    remove_const :HaveClassMethods
+  end
+end

data/lib/maimai_net/page-debug.rb

@@ -0,0 +1,9 @@
+module MaimaiNet
+  module Page
+    class Debug < Base
+      def debug
+        byebug
+      end
+    end if respond_to? :byebug
+  end
+end

data/lib/maimai_net/page-html_helper.rb

@@ -0,0 +1,131 @@
+module MaimaiNet
+  module Page
+    # Interesting on how refinement ON this file affects the use of helper_method block invocation.
+    using IncludeAutoConstant
+
+    # @!api private
+    # scope extension to add various html-related method
+    class HelperBlock < ::BasicObject
+      include ModuleExt
+
+      # copies page instance variables
+      # @param page [Page::Base] page object tp refer
+      def initialize(page)
+        page.instance_variables.map do |k|
+          "#{k} = page.instance_variable_get(#{k.inspect})"
+        end.join($/).tap do |expr|
+          instance_eval expr, __FILE__, __LINE__ + 1
+        end if Page::Base === page
+
+        @_page = page
+      end
+
+      # proxy method
+      private
+      def method_missing(meth, *args, **kwargs, &block)
+        return super unless Page::Base === @_page
+        kwargs.empty? ?
+          @_page.__send__(meth, *args, &block) :
+          @_page.__send__(meth, *args, **kwargs, &block)
+      end
+
+      # checks whether current or proxied object have respective method.
+      # @return [Boolean]
+      def respond_to_missing?(meth, priv=false)
+        return super unless Page::Base === @_page
+        super or @_page.respond_to?(meth, priv)
+      end
+
+      GROUPED_INTEGER = /0|[1-9](?:[0-9]*(?:,[0-9]+)*)/.freeze
+      GROUPED_FREE_INTEGER = /\d+(?:,\d+)*/.freeze
+
+      [[::Kernel, %i(method)]].each do |cls, methods|
+        methods.each do |meth|
+          define_method meth, cls.instance_method(meth)
+        end
+      end
+
+      private
+      # @return [String] stripped text content
+      def strip(node); node&.content.strip; end
+      # @return [String] src attribute of the element
+      def src(node); node['src']; end
+      # @return [Integer] de-grouped the integer string
+      def int(str); str.gsub(',', '').to_i(10); end
+      # scan for the first number-string found on given string
+      # and de-group the number-string into an actual integer
+      # @return [Integer]
+      # @see #int
+      def get_int(content); int(GROUPED_INTEGER.match(content).to_s); end
+      # (see #get_int)
+      # @note This version retrieves potentially padded integer as well.
+      def get_fullint(content); int(GROUPED_FREE_INTEGER.match(content).to_s); end
+      # scan for all number-string found on given string
+      # and de-group all of the string into array of integers
+      # @return [Array<Integer>]
+      def scan_int(content); content.scan(GROUPED_INTEGER).map(&method(:int)); end
+
+      inspect_permit_variable_exclude :_page
+      inspect_permit_expression do |value| false end
+    end
+
+    class << HelperBlock
+      private :new
+    end
+
+    # adds capability to inject methods using hidden helper block
+    module HelperSupport
+      # defines the method to be injected with hidden helper block.
+      # such method have an extended set of capability to use methods
+      # provided on HelperBlock class.
+      # @param meth [Symbol]
+      # @return [Symbol]
+      def helper_method(meth, &block)
+        lock :helper_method, meth do
+          define_method meth do
+            HelperBlock.__send__(:new, self).instance_exec(&block)
+          end
+        end
+      end
+
+      # install an auto-hook for data method for any Page::Base class.
+      # @param meth [Symbol]
+      # @return [void]
+      def method_added(meth)
+        return super unless meth === :data && self <= Page::Base
+
+        lock :helper_method, meth do
+          fail NotImplementedError, "no solution found for method definition rebinding. please use helper_method #{meth.inspect} do ... end block instead."
+
+          # rand_name = '_%0*x' % [0.size << 1, rand(1 << (0.size << 3))]
+          old_meth = instance_method(meth)
+          # obj = allocate
+          # old_meth = obj.method(meth)
+          # HelperBlock.define_method rand_name, old_meth
+          # old_meth = instance_method(rand_name)
+          # p old_meth
+          # remove_method rand_name
+
+          define_method meth do
+            HelperBlock.__send__(:new, self).instance_exec(&old_meth.bind(self))
+          end
+          super
+        end
+      end
+
+      # automatically install mutex upon invoked for an extension
+      # @return [void]
+      def self.extended(cls)
+        cls.class_exec do
+          include ModuleExt::AddInternalMutex
+        end
+      end
+    end
+
+    private_constant :HelperBlock
+
+    class Base
+      extend HelperSupport
+    end
+  end
+end

data/lib/maimai_net/page-player_data_helper.rb

@@ -0,0 +1,33 @@
+module MaimaiNet
+  module Page
+    module PlayerDataHelper
+      def self.process(elm)
+        HelperBlock.send(:new, nil).instance_exec do
+          counter_elements = elm.css <<-CSS.strip
+            div:not(.musiccount_block):not(.clearfix) ~ .musiccount_block:has(~ .clearfix),
+            div:not(.musiccount_block):not(.clearfix) ~ .clearfix:has(~ .clearfix)
+          CSS
+          cascaded_data = []
+          data = []
+          column_id = 0
+          counter_elements.each do |elm|
+            if elm.classes.include?('clearfix') then
+              column_id = 0
+              next
+            end
+
+            cascaded_data << [] if column_id.succ > cascaded_data.size
+
+            cascaded_data[column_id] << Model::SongCount.new(
+              **%i(achieved total).zip(scan_int(strip(elm))).to_h
+            )
+            column_id += 1
+          end
+
+          cascaded_data.each do |column_data| data.concat column_data end
+          data
+        end
+      end
+    end
+  end
+end

data/lib/maimai_net/page-track_result_helper.rb

@@ -0,0 +1,90 @@
+module MaimaiNet
+  module Page
+    module TrackResultHelper
+      using IncludeAutoConstant
+      def self.process(
+        elm,
+        web_id: MaimaiNet::Model::WebID::DUMMY,
+        result_combo: nil,
+        result_sync_score: nil
+      )
+        HelperBlock.send(:new, nil).instance_exec do
+          header_block = elm.at_css('.playlog_top_container')
+          difficulty = ::Kernel.Difficulty(::Kernel.Pathname(src(header_block.at_css('img.playlog_diff'))).sub_ext('').sub(/.+_/, '').basename)
+
+          dx_container_classes = MaimaiNet::Difficulty::DELUXE.select do |k, v| v.positive? end
+            .keys.map do |k| ".playlog_#{k}_container" end
+          # info_block = elm.at_css(*dx_container_classes)
+          info_block = elm.at_css(".playlog_#{difficulty.key}_container")
+          chart_header_block = info_block.at_css('.basic_block')
+          result_block = info_block.at_css('.basic_block ~ div:nth-of-type(1)')
+
+          track_order = get_fullint(strip(header_block.at_css('div.sub_title > span:nth-of-type(1)')))
+          play_time = Time.strptime(
+            strip(header_block.at_css('div.sub_title > span:nth-of-type(2)')) + ' +09:00',
+            '%Y/%m/%d %H:%M %z',
+          )
+          song_name = strip(chart_header_block.children.last)
+          chart_level = strip(chart_header_block.at_css('div:nth-of-type(1)'))
+          song_jacket = src(result_block.at_css('img.music_img'))
+          chart_type = nil
+          result_block.at_css('img.playlog_music_kind_icon')&.tap do |elm|
+            chart_type = ::Kernel.Pathname(src(elm))&.sub_ext('')&.sub(/.+_/, '')&.basename&.to_s
+          end
+
+          result_score = strip(result_block.at_css('.playlog_achievement_txt')).to_f
+          result_deluxe_scores = scan_int(strip(result_block.at_css('.playlog_result_innerblock .playlog_score_block div:nth-of-type(1)')))
+          result_grade = ::Kernel.Pathname(::Kernel.URI(src(result_block.at_css('.playlog_scorerank'))).path).sub_ext('')&.sub(/.+_/, '')&.basename&.to_s.to_sym
+          result_flags = result_block.css('.playlog_result_innerblock > img').map do |elm|
+            flag = ::Kernel.Pathname(::Kernel.URI(src(elm)).path).sub_ext('')&.basename.to_s
+            case flag
+            when *MaimaiNet::AchievementFlag::RESULT.values; MaimaiNet::AchievementFlag.new(result_key: flag)
+            when /_dummy$/; nil
+            end
+          end.compact
+
+          challenge_info = nil
+          result_block.at_css('div:has(> .playlog_life_block)')&.tap do |elm|
+            challenge_type = ::Kernel.Pathname(::Kernel.URI(src(elm.at_css('img:nth-of-type(1)'))).path).basename.sub_ext('').sub(/.+_/, '').to_s.to_sym
+            challenge_lives = scan_int(strip(elm.at_css('.playlog_life_block')))
+
+            challenge_info = Model::Result::Challenge.new(
+              type: challenge_type,
+              lives: Model::Result::Progress.new(**%i(value max).zip(challenge_lives).to_h),
+            )
+          end
+
+          score_data = {
+            score: result_score,
+            **%i(deluxe_score combo sync_score).zip([
+              result_deluxe_scores, result_combo, result_sync_score,
+            ]).reject do |k, li| li.nil? end.map do |k, li|
+              [k, Model::Result::Progress.new(**%i(value max).zip(li).to_h)]
+            end.to_h,
+            grade: result_grade,
+            flags: result_flags.map(&:to_sym),
+          }
+
+          score_cls = score_data.key?(:combo) && score_data.key?(:sync_score) ?
+            Model::Result::Score : Model::Result::ScoreLite
+
+          score_info = score_cls.new(**score_data)
+
+          Model::Result::Track.new(
+            info: Model::Chart::Info.new(
+              web_id: web_id,
+              title: song_name,
+              type: (chart_type or -'unknown'),
+              difficulty: difficulty.id,
+              level_text: chart_level,
+            ),
+            score: score_info,
+            order: track_order,
+            time: play_time,
+            challenge: challenge_info,
+          )
+        end
+      end
+    end
+  end
+end